# Installation sur Bazzite OS

[Bazzite](https://bazzite.gg/) est une distribution **immuable** basée sur Fedora Atomic
(rpm-ostree). Le système de fichiers racine est en lecture seule : on **n'installe pas** de
paquets de développement (`webkit2gtk-devel`, compilateurs…) directement sur l'hôte comme on
le ferait sur une Fedora classique.

Cette contrainte vaut aussi pour les autres systèmes atomiques (Fedora Silverblue, Kinoite,
Universal Blue, openSUSE MicroOS…).

La méthode recommandée est le **Flatpak** : on construit **une seule fois** un fichier
`.flatpak` (le « bundle »), on l'héberge (par ex. sur un dépôt Gitea), puis on l'installe sur
n'importe quelle machine **en une commande**, sans rien compiler ni installer de dépendance
sur l'hôte.

| Vous voulez… | Allez à… |
|---|---|
| **Installer Pena** depuis un `.flatpak` déjà construit (récupéré sur Gitea) | [1. Méthode simple](#1-méthode-simple--installer-le-paquet-pré-construit) |
| **Produire** le fichier `.flatpak` (une fois, sur une machine de build) | [2. Compiler](#2-compiler-le-binaire-une-fois) puis [3. Construire le bundle](#3-construire-le-paquet-flatpak-une-fois) |
| **Développer / itérer** sur le code sans empaqueter | [4. Alternative développeur (distrobox)](#4-alternative-développeur--lancer-via-distrobox) |

> Bazzite fournit **`flatpak`** (avec le dépôt Flathub), **`distrobox`** et **`podman`**
> préinstallés. Aucune surcouche rpm-ostree (`rpm-ostree install`) n'est nécessaire.

---

## 1. Méthode simple — installer le paquet pré-construit

C'est le scénario du quotidien : le fichier `pena.flatpak` a déjà été construit (voir
sections 2 et 3) et déposé sur votre Gitea. Sur la machine cible, il suffit de le récupérer et
de l'installer.

### 1.1 — Installer

```bash
# Récupérer le bundle depuis Gitea (adaptez l'URL à votre dépôt)
curl -L -o pena.flatpak \
  https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/pena.flatpak

# Installer pour l'utilisateur courant (aucun droit root nécessaire)
flatpak install --user pena.flatpak
```

> Le runtime `org.gnome.Platform` (qui fournit WebKitGTK) est téléchargé automatiquement
> depuis Flathub lors de l'installation s'il n'est pas déjà présent. C'est la seule dépendance,
> et elle est gérée par Flatpak — rien à compiler ni à installer sur l'hôte.

### 1.2 — Lancer

```bash
flatpak run com.pena.app
```

Pena apparaît aussi dans le menu des applications de Bazzite.

### 1.3 — Mettre à jour / désinstaller

```bash
# Mettre à jour : récupérer le nouveau bundle puis réinstaller par-dessus
flatpak install --user --reinstall pena.flatpak

# Désinstaller
flatpak uninstall com.pena.app
```

### 1.4 — (Optionnel) Installation en une ligne

Vous pouvez déposer à côté du bundle, sur Gitea, un script `install.sh` qui automatise le
téléchargement et l'installation :

```bash
#!/usr/bin/env bash
set -euo pipefail
URL="https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/pena.flatpak"
TMP="$(mktemp --suffix=.flatpak)"
curl -L -o "$TMP" "$URL"
flatpak install --user -y "$TMP"
rm -f "$TMP"
echo "Pena installé. Lancez-le avec : flatpak run com.pena.app"
```

L'installation se résume alors à :
```bash
curl -L https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/install.sh | bash
```

---

## 2. Compiler le binaire (une fois)

Cette étape et la suivante se font **sur une machine de build** (la vôtre, dans un container).
Le résultat est un fichier `pena.flatpak` que vous n'aurez plus qu'à héberger.

Pena se compile dans un container Ubuntu via **distrobox**, pour ne rien installer sur l'hôte
immuable. WebKitGTK et le compilateur restent dans le container.

```bash
# 1. Créer et entrer dans un container Ubuntu
distrobox create --name pena-build --image ubuntu:24.04
distrobox enter pena-build

# 2. (dans le container) installer les dépendances de build
sudo apt update
sudo apt install -y \
  libwebkit2gtk-4.1-dev build-essential curl wget file \
  libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev git
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source "$HOME/.cargo/env"
cargo install tauri-cli --version "^2"

# 3. (dans le container) compiler
cd ~/Pena/Pena-tauri      # adaptez le chemin vers les sources
cargo tauri build
```

Le binaire est produit dans `src-tauri/target/release/pena-taury`. Vous pouvez ensuite
quitter le container (`exit`) : la suite (section 3) se fait sur l'hôte, où `flatpak` est
disponible. Comme `$HOME` est partagé entre l'hôte et le container, le binaire compilé est
accessible des deux côtés.

---

## 3. Construire le paquet `.flatpak` (une fois)

À partir du binaire compilé, on produit le fichier unique `pena.flatpak`.

### 3.1 — Outillage Flatpak (sur l'hôte)

```bash
flatpak install -y flathub org.gnome.Platform//47 org.gnome.Sdk//47 org.flatpak.Builder
```

### 3.2 — Fichiers d'empaquetage

Depuis la racine `Pena-tauri/`, créez deux fichiers.

**`com.pena.app.desktop`** :
```ini
[Desktop Entry]
Type=Application
Name=Pena
Comment=Lecteur Markdown
Exec=pena
Icon=com.pena.app
Terminal=false
Categories=Utility;Office;
```

**`com.pena.app.yml`** (manifeste Flatpak) :
```yaml
id: com.pena.app
runtime: org.gnome.Platform
runtime-version: '47'
sdk: org.gnome.Sdk
command: pena

finish-args:
  - --share=ipc
  - --socket=wayland
  - --socket=fallback-x11
  - --device=dri
  # Accès en lecture aux fichiers Markdown de l'utilisateur
  - --filesystem=home:ro

modules:
  - name: pena
    buildsystem: simple
    build-commands:
      - install -Dm755 pena-taury /app/bin/pena
      - install -Dm644 com.pena.app.desktop /app/share/applications/com.pena.app.desktop
      - install -Dm644 icon.png /app/share/icons/hicolor/512x512/apps/com.pena.app.png
    sources:
      - type: file
        path: src-tauri/target/release/pena-taury
      - type: file
        path: com.pena.app.desktop
      - type: file
        path: src-tauri/icons/icon.png
```

> L'identifiant `com.pena.app` correspond au champ `identifier` de
> `src-tauri/tauri.conf.json`. Le runtime `org.gnome.Platform` embarque WebKitGTK : l'app
> fonctionnera sans aucune dépendance installée sur la machine cible.

### 3.3 — Construire le bundle

Depuis `Pena-tauri/` :

```bash
# 1. Construire l'app dans un dépôt OSTree local (dossier "repo")
flatpak run org.flatpak.Builder --force-clean --repo=repo \
  --install-deps-from=flathub build-dir com.pena.app.yml

# 2. Exporter en UN SEUL fichier .flatpak
flatpak build-bundle repo pena.flatpak com.pena.app \
  --runtime-repo=https://flathub.org/repo/flathub.flatpakrepo
```

Vous obtenez **`pena.flatpak`** : c'est ce fichier unique, autoportant, que vous installez
partout (section 1). L'option `--runtime-repo` y inscrit la référence vers Flathub, pour que
le runtime soit récupéré automatiquement à l'installation.

### 3.4 — Héberger sur Gitea

Déposez `pena.flatpak` sur votre dépôt Gitea, soit :
- en l'ajoutant au dépôt (`git add pena.flatpak`) — simple, mais alourdit l'historique ;
- **de préférence**, en l'attachant à une **release** Gitea (onglet *Releases* → *New Release*
  → joindre le binaire). L'URL de téléchargement direct est alors stable et n'encombre pas le
  dépôt.

Adaptez ensuite l'URL utilisée à la [section 1.1](#11--installer).

---

## 4. Alternative développeur — lancer via distrobox

Si vous **développez** sur Pena et n'avez pas besoin d'un paquet installable, vous pouvez
exécuter l'application directement depuis le container, sans passer par Flatpak.

```bash
# Lancement direct (la fenêtre s'affiche sur le bureau de l'hôte)
distrobox enter pena-build -- bash -lc 'cd ~/Pena/Pena-tauri && cargo tauri dev'
```

Pour exposer le binaire compilé à l'hôte comme une commande :

```bash
# Depuis le container, après "cargo tauri build"
distrobox-export --bin ~/Pena/Pena-tauri/src-tauri/target/release/pena-taury \
  --export-path ~/.local/bin
```

Le binaire devient lançable depuis l'hôte (`~/.local/bin` doit être dans le `PATH`). Cette
voie est pratique pour itérer, mais le Flatpak (sections 1–3) reste la méthode recommandée
pour une **installation** propre et reproductible.

---

## Note — AppImage

Une autre forme de « fichier unique à exécuter » est l'**AppImage** : un binaire autoportant
qui se lance sans installation (`chmod +x Pena.AppImage && ./Pena.AppImage`). Tauri sait en
produire, mais cela nécessite d'activer le bundler (`bundle.active: true` dans
`tauri.conf.json`, cible `appimage`) et l'outillage associé. Le **bundle Flatpak** décrit
ci-dessus est privilégié ici car il s'intègre au menu, se met à jour proprement et gère
automatiquement ses dépendances via Flathub.

## Voir aussi

- [Release et distribution](3.4-Release-et-distribution.md) — pourquoi le Flatpak, portabilité et trade-offs des formats
- [Build et compilation](3.3-Build.md)
- [Installation (Linux générique / Fedora)](3.1-Installation.md)
- [Architecture](../2-technique/2.1-Architecture.md)