# ori-desktop — une coquille de bureau Wails pour ori

`ori-desktop` enveloppe le client web [ori](../README.md) dans une fenêtre native construite
avec [Wails v2](https://wails.io) (Go + la webview de la plateforme). Il ne réimplémente **pas**
ori : le serveur ori continue de servir la SPA React et les points d'entrée `/ws`, `/api/files`,
`/ws/terminal`. L'application de bureau se contente de

1. afficher un petit **écran de connexion** avec l'URL du serveur ori (par défaut
   `http://localhost:8888`), mémorisée d'une exécution à l'autre dans un fichier JSON ;
2. vérifier le serveur avec **`GET /healthz`** via une méthode Go exposée au frontend ;
3. puis afficher **la webapp ori elle-même** dans la fenêtre.

C'est un module Go séparé (`rickub.com/bots-garden/ori-desktop`) : le `go test ./...` et le
`make build` du dépôt parent ne sont pas affectés.

## Prérequis

- Go 1.25+ (exigence de Wails v2.16, reprise par le module).
- La CLI Wails v2 : `go install github.com/wailsapp/wails/v2/cmd/wails@v2.16.0`
  (puis vérifier que `$(go env GOPATH)/bin` est dans le `PATH`).
- La chaîne d'outils graphique attendue par Wails — `wails doctor` liste ce qui manque :
  - **Linux** : `gcc`, `pkg-config`, `libgtk-3-dev`, `libwebkit2gtk-4.0-dev` (ou `-4.1-dev`
    avec `-tags webkit2_41`) ;
  - **macOS** : les Xcode command line tools ;
  - **Windows** : le runtime WebView2 (préinstallé sur Windows 10/11) ; NSIS seulement pour
    l'installeur.
- Un serveur ori en marche. Depuis la racine du dépôt : `make run` ou `make run-mock`.

Aucun Node/npm n'est nécessaire : le frontend est du HTML/CSS/JS pur embarqué tel quel (pas de
bundler).

## Lancer en mode développement

```bash
cd ori-desktop
wails dev
```

`wails dev` compile la partie Go, ouvre la fenêtre et recharge le frontend à chaque modification
sous `frontend/src/` (`assetdir` dans `wails.json`). Il sert aussi l'application sur
http://localhost:34115 pour l'ouvrir dans un navigateur classique avec les devtools tout en
appelant les méthodes Go.

## Construire un binaire distribuable

```bash
cd ori-desktop
wails build            # → build/bin/ori-desktop (ou .app / .exe)
# ou, depuis la racine du dépôt :
make desktop
```

La compilation croisée vers Windows depuis Linux/macOS fonctionne sans chaîne C :
`wails build -platform windows/amd64` → `build/bin/ori-desktop.exe`.

## Tests

La logique de connexion est en Go pur et testée sans aucune dépendance graphique :

```bash
cd ori-desktop && go test ./internal/...
# ou, depuis la racine du dépôt :
make desktop-test
```

`internal/settings` couvre les allers-retours chargement/sauvegarde, les valeurs par défaut au
premier lancement, les fichiers invalides et la normalisation d'URL ; `internal/health` couvre
`/healthz` face à un serveur `httptest` (sain, non-ori, injoignable, contexte annulé).

## Comment il se connecte à ori

```
┌──────────────── ori-desktop (fenêtre Wails) ───────────────┐
│ frontend/src (embarqué, origine wails://)                   │
│   écran de connexion ──► window.go.main.App.Connect(url)    │
│                             │ Go : NormalizeURL → GET /healthz → sauvegarde des réglages
│                             ▼                               │
│   <iframe src="http://localhost:8888/">  ◄── le serveur ori sert la SPA,
│        la SPA ouvre ws://localhost:8888/ws, /ws/terminal, /api/files comme d'habitude
└─────────────────────────────────────────────────────────────┘
```

**Pourquoi une iframe ?** Wails v2 n'offre aucun appel runtime pour faire naviguer la webview
principale vers une URL externe ; la fenêtre affiche toujours le frontend embarqué
(`runtime.BrowserOpenURL` ouvre le navigateur système, proposé comme solution de repli « Open in
browser »). Charger ori dans une `<iframe>` conserve une fine barre native (URL, Reload, Open in
browser, Disconnect) autour de la SPA ori intacte. Cela fonctionne parce qu'ori n'envoie ni
en-tête `X-Frame-Options` ni CSP `frame-ancestors`, et parce que la SPA dérive ses URL
WebSocket de `window.location` — dans l'iframe c'est l'origine ori elle-même, donc le contrôle
d'origine `localhost:*` des WebSockets d'ori est satisfait.

Sur macOS, `build/darwin/Info.plist` positionne `NSAppTransportSecurity/NSAllowsLocalNetworking`
pour qu'App Transport Security autorise le chargement HTTP en clair sur la boucle locale.

### Méthodes Go exposées au frontend (`app.go`)

| Méthode | Rôle |
| --- | --- |
| `GetConfig() → settings.Settings` | Réglages mémorisés (valeurs par défaut au premier lancement). |
| `SaveConfig(settings.Settings)` | Normalise l'URL puis persiste. |
| `CheckHealth(url) → health.Report` | `GET <url>/healthz` ; ne rejette jamais — `ok`, `statusCode`, `detail`. |
| `Connect(url) → string` | Normalise, vérifie la santé, mémorise l'URL, renvoie l'URL de base à charger. |
| `OpenInBrowser(url)` | Repli `runtime.BrowserOpenURL`. |
| `SettingsPath() → string` | Emplacement du fichier de réglages (affiché à l'écran). |

Le frontend les appelle via `window.go.main.App.<Méthode>()` (Promesses). Les wrappers typés
générés par `wails dev`/`wails build` sous `frontend/wailsjs/` sont ignorés par git car rien ne
les importe ; `wails generate module` les régénère si l'on veut les fichiers `.d.ts`.

### Fichier de réglages

`<répertoire de configuration utilisateur>/ori-desktop/settings.json`, soit
`~/.config/ori-desktop/settings.json` sous Linux, `~/Library/Application
Support/ori-desktop/settings.json` sous macOS, `%AppData%\ori-desktop\settings.json` sous
Windows :

```json
{
  "serverUrl": "http://localhost:8888"
}
```

## Arborescence

```
ori-desktop/
├── main.go              amorçage Wails (options de fenêtre, assets embarqués, bindings)
├── app.go               méthodes Go exposées au frontend
├── wails.json           configuration du projet Wails
├── internal/settings/   fichier de réglages (chargement/sauvegarde/normalisation) + tests
├── internal/health/     sonde GET /healthz + tests
├── frontend/src/        index.html, main.css, main.js (module ES embarqué, sans bundler)
└── build/               assets de build Wails (icône, Info.plist, manifeste Windows) ; build/bin est la sortie
```

## État / limites connues

- Vérifié à ce jour : tests unitaires, `go vet`, et une compilation croisée Windows
  (`wails build -platform windows/amd64`) depuis un bac à sable Linux sans bibliothèques
  graphiques. La fenêtre elle-même n'a pas encore été lancée (pas de WebKitGTK dans ce bac à
  sable) — voir les notes `.memory/` du dépôt.
- ori est chargé en HTTP clair ; à réserver à des serveurs locaux ou de confiance.
- Un ori lancé avec un autre `--addr` que `:8888` se rejoint simplement en saisissant l'URL
  correspondante sur l'écran de connexion.