ori-desktop — une coquille de bureau Wails pour ori

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

# 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.