feat: v0.1.0 — client Sailfish per hermes-webui con voce

- ApiClient HTTP/SSE: login, sessioni, chat/start, stream SSE, transcribe, tts - ChatModel: streaming live + risincronizzazione dallo stato del server - CookieJar persistente (0600, mai la password); Settings - Recorder OGG/Opus (fallback WAV/PCM, retry); Player TTS (QMediaPlayer) - UI Silica: splash, login, sessioni, chat (dettatura + read-aloud), settings, cover - Sailjail Internet;Audio;Microphone; icone; spec RPM; docs PROTOCOL/BUILD - tests/core_test: unit parser SSE + integrazione live (probe :8899)
2026-09-12 07:11:20 +02:00
commit 9c6a1242f7
36 changed files with 2954 additions and 0 deletions
@@ -0,0 +1,8 @@
 *.o
 moc_*
 qmake.stash
 Makefile*
 *.qm
 build/
 core-test
 *.tar.gz
@@ -0,0 +1,34 @@
 # harbour-hermes
 Native **Sailfish OS** client for the **Hermes Web UI** (`hermes-webui`):
 chat with your Hermes agent from the phone — and use it with your **voice**.
 ## Features
 - Sign in to your Hermes Web UI (session cookie persisted; password never stored)
 - Sessions list, new session, open any session
 - Chat with **live streaming** replies (SSE token deltas)
 - **Voice dictation**: tap Mic, speak, tap Stop → server-side Whisper
  transcription lands in the composer
 - **Read aloud**: server-side TTS (edge engine, Italian voices) played through
  QMediaPlayer; optional auto-read of every completed reply
 - Cancel a running turn, resync from server state, cover page
 ## Requirements
 - Sailfish OS 4.4+ (developed against Sailfish 5.1)
 - A running `hermes-webui` instance reachable over HTTPS (default:
  `https://hermes.hackatoniclife.com`)
 - Sailjail permissions `Internet;Audio;Microphone` (declared in the .desktop)
 ## Build
 See [docs/BUILD.md](docs/BUILD.md) (Sailfish SDK, `sfdk build` / `sfdk deploy`)
 and [docs/PROTOCOL.md](docs/PROTOCOL.md) for the HTTP/SSE protocol the app
 speaks (validated live against a real instance).
 ## Status
 Version 0.1.0 — protocol and C++ core validated against a real `hermes-webui`
 (login, sessions, streaming chat, TTS, STT); on-device testing (audio paths,
 Sailjail prompts, keyboard handling) still pending.
@@ -0,0 +1,93 @@
 # Build: compilazione, test e deploy
 ## 1. Prerequisiti SDK
 - Sailfish SDK (testato su 5.1.0.11) con target del dispositivo aarch64:
  `SailfishOS-5.0.0.62-aarch64` (Jolla Phone 2026) o equivalente.
 - Nel target SDK serve **QtMultimedia** (registrazione/riproduzione):
  se `pkgconfig(Qt5Multimedia)` non è trovato in fase di build, installa il
  pacchetto devel nel target:
  ```bash
  sfdk tools exec SailfishOS-5.0.0.62-aarch64 zypper install -y qt5-qtmultimedia-devel
  ```
  (oppure via Qt Creator: Tools → Sailfish OS → Manage targets → Packages,
  oppure `sfdk target install` con un RPM locale.)
 ## 2. Build e deploy dell'app
 ```bash
 cd harbour-hermes
 sfdk build          # genera RPMS/
 sfdk deploy         # installa sul device collegato
 ```
 Note:
 - Il target è Qt 5.6: il codice del core è scritto per compilare anche lì
  (niente API Qt > 5.6; per il TTS si usa `audio/mpeg` di edge-tts).
 - Il profilo SailJail è nel `rpm/harbour-hermes.desktop`
  (`Internet;Audio;Microphone`) e deve restare allineato a
  `setOrganizationName("harbour")` / `setApplicationName("hermes")` in `main.cpp`.
 - Al primo uso del microfono Sailfish chiede il consenso al permesso
  **Microphone**.
 ## 3. Test del core in locale (senza SDK)
 Il core (ApiClient, ChatModel, parser SSE, Recorder, Player) si compila anche
 su desktop con Qt 5.15 per i test:
 ```bash
 # Qt desktop (qui: Qt 5.15.2 nel kit locali)
 export PATH=<Qt5.15>/gcc_64/bin:$PATH
 mkdir -p /tmp/hh-test && cd /tmp/hh-test
 qmake /percorso/harbour-hermes/tests/core_test.pro
 make -j4
 ```
 - **Unit** (parser SSE): `./core-test`
 - **Integrazione live**: `./core-test --live`
  richiede un'istanza di prova di hermes-webui su `http://127.0.0.1:8899`
  con password in `/tmp/hermes-probe/pw` e l'audio di prova in
  `/tmp/hermes-probe/out/prova.ogg` (vedi note in `tests/core_test.cpp`).
  Il flusso coperto: login → nuova sessione → turno con streaming → TTS →
  trascrizione.
 Nota desktop: se manca `libGL.so` di sviluppo, creare un symlink
 `libGL.so -> /usr/lib/x86_64-linux-gnu/libGL.so.1` e assicurarsi che
 `core_test.pro` punti lì (`GLSTUB`), oppure lanciare con `LD_LIBRARY_PATH`
 puntato alla lib dir di Qt.
 ## 4. Tarball per la build da Qt Creator
 ```bash
 cd /home/kaneda/workspace
 tar czf harbour-hermes-0.1.0.tar.gz \
    --transform 's,^harbour-hermes,harbour-hermes-0.1.0,' \
    --exclude='.git' harbour-hermes
 ```
 Lo spec si aspetta la directory `harbour-hermes-0.1.0/` (pattern degli altri
 progetti: cercato in modo robusto anche per i sorgenti live di sfdk).
 ## 5. Dipendenze lato server (WebUI)
 - `/api/transcribe` richiede un provider STT attivo sul server
  (qui: faster-whisper locale — verificato con `/api/transcribe/capability`).
 - `/api/tts` con engine `edge` non richiede chiavi API.
 - Le voci italiane di edge sono state aggiunte all'allowlist del server
  (patch a `hermes-webui/api/routes.py` + test
  `tests/test_italian_voices_tts_allowlist.py`): per attivarle **riavviare
  il servizio WebUI** (`sudo systemctl restart hermes-webui`).
 - Per una dettatura italiana corretta impostare in `~/.hermes/config.yaml`:
  ```yaml
  stt:
    provider: local
    local:
      model: base
      language: it
  ```
  (senza, whisper può tradurre/maltrascrivere l'italiano). Richiede il
  riavvio del WebUI.
@@ -0,0 +1,175 @@
 # Protocollo `hermes-webui` ↔ client
 Documentazione del protocollo HTTP/SSE usato da harbour-hermes.
 **Validato dal vivo il 12/09/2026** contro un'istanza reale di
 `nesquena/hermes-webui` (v0.52.x, `server.py`, ThreadingHTTPServer).
 > Il protocollo non è documentato ufficialmente: è replicato dal frontend web
 > del progetto (`static/*.js` è la reference implementation) e pinnato alla
 > versione attuale. Un aggiornamento del WebUI può richiedere aggiornamenti
 > al client.
 Server di riferimento: in ascolto su `127.0.0.1:8787` dietro reverse proxy
 (`https://hermes.hackatoniclife.com`). TLS obbligatorio in produzione.
 ## 1. Autenticazione
 Cookie di sessione **`hermes_session`** = `token.firma_hmac` (TTL 30 giorni
 di default; `HERMES_WEBUI_SESSION_TTL` per cambiarlo). Auth attiva solo se il
 server ha una password impostata.
 | Endpoint | Metodo | Body / Risposta |
 |---|---|---|
 | `/api/auth/login` | POST | `{"password": "..."}` → `200 {"ok": true}` + `Set-Cookie` |
 | `/api/auth/status` | GET | `{"auth_enabled": bool, "logged_in": bool, "password_auth_enabled": bool, ...}` |
 | `/api/auth/logout` | POST | invalida il cookie |
 - Errori: `401 {"error": "Authentication required"}`; rate limit sul login.
 - Se `auth_enabled` è `false`, tutte le API rispondono senza cookie.
 - Il client persiste SOLO il cookie (file `0600`); la password non è mai salvata.
 ## 2. Sessioni
 `GET /api/sessions` → lista per la sidebar:
 ```json
 {
  "sessions": [
    {
      "session_id": "171ff18f9313",
      "title": "Webui Session",
      "workspace": "/home/kaneda/.hermes/profiles/carlo/home/workspace",
      "model": "deepseek-v4-flash",
      "model_provider": "deepseek",
      "message_count": 2,
      "created_at": 1785701975.8797414,
      "updated_at": 1785701985.0872252,
      "pinned": false, "archived": false,
      "profile": "default",
      "source_tag": "webui", "session_source": "webui",
      "is_cli_session": false, "is_streaming": false,
      "active_stream_id": null
    }
  ],
  "active_profile": "default",
  "server_time": 1789188804.1041577
 }
 ```
 `GET /api/session?session_id=ID` → `{"session": { ... }}` con in più:
 - `messages`: array di `{"role": "user"|"assistant", "content": "...",
  "timestamp": 1789188869.6, ...}` (i messaggi assistente possono includere
  `reasoning`, `finish_reason`, `id`, `_turnDuration`, `_turnTps`,
  `_firstTokenMs`; i messaggi "solo tool" hanno `content` vuoto)
 - `tool_calls`, `input_tokens`, `output_tokens`, `estimated_cost`,
  `read_only`, `active_stream_id`, `enabled_toolsets`, ...
 `POST /api/session/new` con body `{"workspace": "/path"}` (opzionale; il
 workspace deve essere sotto la home dell'utente, nella lista salvata o sotto
 il default) → `{"session": {...}}` (sessione vuota).
 ## 3. Chat con streaming
 `POST /api/chat/start`:
 ```json
 {
  "session_id": "f517dae7a2da",
  "message": "Rispondi solo con la parola pong",
  "model": "deepseek-v4-flash",
  "model_provider": "deepseek",
  "workspace": "/home/kaneda/.hermes/profiles/carlo/home/workspace",
  "profile": "default"
 }
 ```
 Risposta:
 ```json
 {
  "stream_id": "a1e0ec82169b4673a13bf9bd466afd3f",
  "session_id": "f517dae7a2da",
  "pending_started_at": 1789188858.196835,
  "turn_id": "20260912T045418Z-ba85fcc8cebe",
  "title": "Rispondi solo con la parola pong. Non usare strumenti.",
  "effective_model_provider": "deepseek"
 }
 ```
 Errori noti: `404` sessione inesistente; `400` "Missing required field(s)";
 conflitto se la sessione ha già uno stream attivo ("session already has an
 active stream").
 `GET /api/chat/stream?stream_id=ID` → **SSE** `text/event-stream`,
 heartbeat ogni 5 s (`: heartbeat`), ogni evento ha `id: <stream_id>:<seq>`:
 | Evento | Payload | Uso nel client |
 |---|---|---|
 | `context_status` | `{session_id, prefill}` | ignorato |
 | `token` | `{"text": "..."}` | **delta di testo** della risposta |
 | `metering` | `{tps, ttft_ms, usage, ...}` | ignorato (v1) |
 | `done` | `{"session": {...con messages finali}, "usage": {...}}` | **risincronizza** il modello e chiude il turno |
 | `title_status` | `{session_id, status, title}` | ignorato |
 | `title` | `{session_id, "title": "..."}` | aggiorna il titolo |
 | `stream_end` | `{session_id}` | fine stream |
 Altri eventi possono esistere (attività tool, approval/clarify) e vanno
 **ignorati** senza errore (il parser li scarta).
 Ripresa: `GET /api/chat/stream/status?stream_id=ID` →
 `{"active": bool, "stream_id", "replay_available"}`. Se `GET /api/session`
 mostra `active_stream_id` non nullo, riagganciare lo stream con lo stesso URL.
 Annullamento: `GET /api/chat/cancel?stream_id=ID` →
 `{"ok": true, "cancelled": bool, "stream_id"}`.
 ## 4. Voce
 ### Trascrizione (voce → testo)
 `POST /api/transcribe` — `multipart/form-data`, campo **`file`**
 (OGG/Opus, WebM, M4A, WAV...; il server converte con ffmpeg se serve):
 ```json
 {"ok": true, "transcript": "Questa è una prova di trascrizione vocale..."}
 ```
 - Provider STT del server (qui: `local` = faster-whisper). Latenza osservata:
  ~10 s per 6 s di audio (modello `base`, CPU).
 - ⚠️ **Lingua**: con `stt.local.language: ''` whisper può tradurre l'italiano
  in inglese; impostare `stt.local.language: it` in `~/.hermes/config.yaml`
  (richiede riavvio del WebUI).
 - `GET /api/transcribe/capability` → `{"ok": true, "available": true, "provider": "local"}`.
 ### Sintesi (testo → voce)
 `POST /api/tts` — JSON:
 ```json
 {"text": "Ciao", "voice": "it-IT-ElsaNeural", "engine": "edge",
 "rate": "+0%", "pitch": "+0Hz"}
 ```
 → `200` `audio/mpeg` (mp3) oppure `4xx` `{"error": "..."}`.
 - Limiti server: **5000 caratteri**; rate limit **2 s per client**;
  **allowlist voci hardcoded** nella funzione `_handle_tts` di
  `api/routes.py`. Voci ammesse oggi: zh-CN (5), en-US (2), fr-CA (4),
  fr-FR (3), id-ID (1) + **it-IT (4: ElsaNeural, DiegoNeural, IsabellaNeural,
  GiuseppeMultilingualNeural)** — le italiane sono state aggiunte da noi
  (patch + test): il server va **riavviato** per attivarle.
 - Engine: `edge` (default, gratis), `elevenlabs`, `openai` (richiedono chiavi
  configurate sul server). `browser` è solo client-side, non usabile qui.
 ## 5. Note operative
 - Tutti gli errori API sono JSON `{"error": "..."}`.
 - Il server non espone CORS: il client nativo non serve preflight.
 - Endpoint utili non usati dalla v1: `/api/clarify/*` e `/api/approval/*`
  (richieste interattive dell'agente: vanno gestite per non lasciare un run
  in attesa), `/api/upload` (allegati), `/api/settings`, `/api/models`,
  `/api/sessions/events` (SSE globale di invalidazione lista).
 - L'istanza di prova usata per la validazione era isolata (porta 8899,
  `HERMES_WEBUI_STATE_DIR` dedicata, password temporanea) e non ha toccato
  né il server live né i dati utente.
@@ -0,0 +1,47 @@
 TEMPLATE = app
 TARGET = harbour-hermes
 CONFIG += sailfishapp
 CONFIG += c++11
 QT += network
 QT += multimedia
 SOURCES += \
    src/main.cpp \
    src/settings.cpp \
    src/cookiejar.cpp \
    src/sseparser.cpp \
    src/apiclient.cpp \
    src/chatmodel.cpp \
    src/recorder.cpp \
    src/player.cpp
 HEADERS += \
    src/settings.h \
    src/cookiejar.h \
    src/sseparser.h \
    src/apiclient.h \
    src/chatmodel.h \
    src/recorder.h \
    src/player.h
 OTHER_FILES += \
    qml/harbour-hermes.qml \
    qml/pages/*.qml \
    qml/cover/*.qml \
    rpm/harbour-hermes.spec \
    rpm/harbour-hermes.desktop
 DISTFILES += $$OTHER_FILES
 # Icone installate via make install (struttura standard hicolor)
 icons86.path = /usr/share/icons/hicolor/86x86/apps
 icons86.files = $$PWD/icons/86x86/harbour-hermes.png
 icons108.path = /usr/share/icons/hicolor/108x108/apps
 icons108.files = $$PWD/icons/108x108/harbour-hermes.png
 icons128.path = /usr/share/icons/hicolor/128x128/apps
 icons128.files = $$PWD/icons/128x128/harbour-hermes.png
 icons172.path = /usr/share/icons/hicolor/172x172/apps
 icons172.files = $$PWD/icons/172x172/harbour-hermes.png
 INSTALLS += icons86 icons108 icons128 icons172
@@ -0,0 +1,30 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 CoverBackground {
    Label {
        id: title
        anchors.top: parent.top
        anchors.topMargin: Theme.paddingLarge
        anchors.horizontalCenter: parent.horizontalCenter
        text: "Hermes"
        font.pixelSize: Theme.fontSizeLarge
        color: Theme.highlightColor
    }
    Label {
        anchors.centerIn: parent
        text: chat.count + qsTr(" messages")
        color: Theme.primaryColor
    }
    Label {
        anchors.bottom: parent.bottom
        anchors.bottomMargin: Theme.paddingLarge
        anchors.horizontalCenter: parent.horizontalCenter
        visible: chat.busy || recorder.recording
        font.pixelSize: Theme.fontSizeExtraSmall
        color: Theme.secondaryColor
        text: recorder.recording ? qsTr("Recording…") : qsTr("Writing…")
    }
 }
@@ -0,0 +1,14 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 import "pages"
 import "cover"
 ApplicationWindow {
    id: app
    initialPage: Component { SplashPage {} }
    cover: Component { CoverPage {} }
    allowedOrientations: Orientation.Portrait
    _defaultPageOrientations: Orientation.Portrait
 }
@@ -0,0 +1,240 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 // Conversazione con Hermes: bolle, streaming live, composer con dettatura.
 Page {
    id: page
    property string sessionId
    property string noticeText: ""
    // Altezza tastiera: alza il composer quando la tastiera e' aperta.
    property real kbHeight: Qt.inputMethod.visible
        ? Math.max(0, page.height - Qt.inputMethod.keyboardRectangle.y)
        : 0
    allowedOrientations: Orientation.Portrait
    SilicaListView {
        id: list
        anchors.top: parent.top
        anchors.left: parent.left
        anchors.right: parent.right
        anchors.bottom: composer.top
        model: chat
        spacing: Theme.paddingSmall
        clip: true
        header: Item {
            width: list.width
            height: headerCol.height
            Column {
                id: headerCol
                width: parent.width
                PageHeader {
                    title: chat.title.length > 0 ? chat.title : qsTr("Chat")
                }
                Label {
                    x: Theme.horizontalPageMargin
                    width: parent.width - 2 * Theme.horizontalPageMargin
                    font.pixelSize: Theme.fontSizeExtraSmall
                    color: Theme.secondaryHighlightColor
                    visible: chat.busy || player.playing
                    text: chat.busy ? qsTr("Hermes is writing…")
                                    : qsTr("Speaking…")
                }
            }
        }
        PullDownMenu {
            MenuItem {
                text: qsTr("Read last reply aloud")
                onClicked: page.readLast()
            }
            MenuItem {
                text: appSettings.ttsAutoRead ? qsTr("Auto-read: on") : qsTr("Auto-read: off")
                onClicked: appSettings.ttsAutoRead = !appSettings.ttsAutoRead
            }
            MenuItem {
                text: qsTr("Stop playback")
                visible: player.playing
                onClicked: player.stop()
            }
            MenuItem {
                text: qsTr("Cancel run")
                visible: chat.busy
                onClicked: chat.cancel()
            }
            MenuItem {
                text: qsTr("Resync")
                onClicked: chat.resync()
            }
        }
        delegate: Item {
            id: row
            width: list.width
            height: bubble.height + Theme.paddingMedium
            Rectangle {
                id: bubble
                property real maxW: list.width - 2 * Theme.horizontalPageMargin
                width: Math.min(lbl.implicitWidth + 2 * Theme.paddingMedium, maxW)
                height: lbl.height + 2 * Theme.paddingSmall
                radius: Theme.paddingSmall
                x: model.role === "user"
                   ? list.width - width - Theme.horizontalPageMargin
                   : Theme.horizontalPageMargin
                color: model.role === "user"
                       ? Theme.rgba(Theme.highlightBackgroundColor, 0.35)
                       : Theme.rgba(Theme.secondaryHighlightColor, 0.18)
                Label {
                    id: lbl
                    x: Theme.paddingMedium
                    y: Theme.paddingSmall
                    width: Math.min(implicitWidth, bubble.maxW - 2 * Theme.paddingMedium)
                    wrapMode: Text.Wrap
                    color: Theme.primaryColor
                    text: model.content + (model.streaming ? " ▍" : "")
                }
            }
        }
    }
    Rectangle {
        id: composer
        anchors.left: parent.left
        anchors.right: parent.right
        anchors.bottom: parent.bottom
        anchors.bottomMargin: page.kbHeight
        height: compCol.height + Theme.paddingMedium
        color: Theme.highlightDimmerColor
        Column {
            id: compCol
            width: parent.width
            spacing: Theme.paddingSmall / 2
            Label {
                x: Theme.horizontalPageMargin
                width: parent.width - 2 * Theme.horizontalPageMargin
                font.pixelSize: Theme.fontSizeExtraSmall
                color: recorder.recording ? Theme.highlightColor
                                          : Theme.secondaryHighlightColor
                visible: recorder.recording || api.transcribing || page.noticeText.length > 0
                truncationMode: TruncationMode.Fade
                text: recorder.recording
                      ? qsTr("Recording… %1 — tap Stop to transcribe").arg(page.formatMs(recorder.durationMs))
                      : api.transcribing
                        ? qsTr("Transcribing…")
                        : page.noticeText
            }
            Row {
                x: Theme.horizontalPageMargin
                width: parent.width - 2 * Theme.horizontalPageMargin
                spacing: Theme.paddingSmall
                Button {
                    id: micBtn
                    text: recorder.recording ? qsTr("Stop") : qsTr("Mic")
                    highlighted: recorder.recording
                    enabled: !api.transcribing && !chat.busy || recorder.recording
                    onClicked: {
                        if (recorder.recording)
                            recorder.stop()
                        else {
                            player.stop()
                            recorder.start()
                        }
                    }
                }
                TextField {
                    id: input
                    width: parent.width - micBtn.width - sendBtn.width - 2 * parent.spacing
                    placeholderText: qsTr("Message…")
                    onAccepted: page.doSend()
                }
                Button {
                    id: sendBtn
                    text: qsTr("Send")
                    enabled: input.text.length > 0 && !chat.busy
                    onClicked: page.doSend()
                }
            }
        }
    }
    Timer {
        id: scrollDebounce
        interval: 150
        onTriggered: list.positionViewAtEnd()
    }
    Timer {
        id: noticeClear
        interval: 5000
        onTriggered: page.noticeText = ""
    }
    Connections {
        target: chat
        onRowCountChanged: scrollDebounce.restart()
        onStreamTick: scrollDebounce.restart()
        onAssistantFinished: {
            if (appSettings.ttsAutoRead)
                page.readLast()
        }
        onNotice: page.showNotice(text)
    }
    Connections {
        target: api
        onTranscriptionReady: {
            input.text = text
            input.focus = true
        }
        onTranscriptionFailed: page.showNotice(error)
        onTtsFailed: page.showNotice(error)
    }
    Component.onCompleted: {
        if (sessionId.length > 0)
            chat.openSession(sessionId)
    }
    function doSend() {
        var t = input.text
        if (t.trim().length === 0)
            return
        input.text = ""
        chat.send(t)
        scrollDebounce.restart()
    }
    function readLast() {
        var t = chat.lastAssistantText()
        if (t.length === 0) {
            page.showNotice(qsTr("No reply to read yet"))
            return
        }
        api.speak(t)
    }
    function showNotice(text) {
        page.noticeText = text
        noticeClear.restart()
    }
    function formatMs(ms) {
        var s = Math.floor(ms / 1000)
        var m = Math.floor(s / 60)
        s = s % 60
        return m + ":" + (s < 10 ? "0" + s : s)
    }
 }
@@ -0,0 +1,76 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 // Login alla Web UI di Hermes: URL del server + password.
 // La password non viene salvata: dopo il login resta il cookie di sessione.
 Page {
    id: page
    Column {
        anchors.left: parent.left
        anchors.right: parent.right
        spacing: Theme.paddingLarge
        PageHeader { title: qsTr("Sign in") }
        Label {
            x: Theme.horizontalPageMargin
            width: parent.width - 2 * Theme.horizontalPageMargin
            wrapMode: Text.WordWrap
            font.pixelSize: Theme.fontSizeSmall
            color: Theme.secondaryColor
            text: qsTr("Use the same password you use in the Hermes Web UI in your browser.")
        }
        TextField {
            id: urlField
            width: parent.width
            label: qsTr("Server")
            placeholderText: "https://hermes.example.com"
            inputMethodHints: Qt.ImhUrlCharactersOnly | Qt.ImhNoAutoUppercase
        }
        TextField {
            id: passField
            width: parent.width
            label: qsTr("Password")
            echoMode: TextInput.Password
            inputMethodHints: Qt.ImhNoAutoUppercase | Qt.ImhNoPredictiveText
            onAccepted: page.doLogin()
        }
        Button {
            anchors.horizontalCenter: parent.horizontalCenter
            text: api.busy ? qsTr("Signing in…") : qsTr("Sign in")
            enabled: !api.busy && passField.text.length > 0
            onClicked: page.doLogin()
        }
        Label {
            x: Theme.horizontalPageMargin
            width: parent.width - 2 * Theme.horizontalPageMargin
            wrapMode: Text.WordWrap
            visible: api.lastError.length > 0
            color: Theme.errorColor
            text: api.lastError
        }
    }
    Connections {
        target: api
        onLoggedInChanged: {
            if (api.loggedIn)
                pageStack.replace(Qt.resolvedUrl("SessionsPage.qml"))
        }
    }
    Component.onCompleted: urlField.text = appSettings.baseUrl
    function doLogin() {
        if (passField.text.length === 0)
            return
        api.clearError()
        appSettings.baseUrl = urlField.text
        api.login(passField.text)
    }
 }
@@ -0,0 +1,115 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 // Lista delle sessioni della Web UI di Hermes (sidebar).
 Page {
    id: page
    // true solo quando e' questa pagina a chiedere una nuova sessione:
    // serve a distinguere la creazione dall'apertura di una sessione esistente.
    property bool expectNewSession: false
    SilicaListView {
        id: list
        anchors.fill: parent
        model: api.sessions
        spacing: Theme.paddingSmall
        header: PageHeader { title: qsTr("Sessions") }
        PullDownMenu {
            MenuItem {
                text: qsTr("New session")
                onClicked: page.createSession()
            }
            MenuItem {
                text: qsTr("Refresh")
                onClicked: api.refreshSessions()
            }
            MenuItem {
                text: qsTr("Settings")
                onClicked: pageStack.push(Qt.resolvedUrl("SettingsPage.qml"))
            }
            MenuItem {
                text: qsTr("Sign out")
                onClicked: api.logout()
            }
        }
        delegate: ListItem {
            id: item
            contentHeight: col.height + Theme.paddingMedium
            Column {
                id: col
                x: Theme.horizontalPageMargin
                width: parent.width - 2 * Theme.horizontalPageMargin
                anchors.verticalCenter: parent.verticalCenter
                spacing: Theme.paddingSmall / 2
                Label {
                    width: parent.width
                    truncationMode: TruncationMode.Fade
                    color: item.highlighted ? Theme.highlightColor : Theme.primaryColor
                    text: ("" + model.title).length > 0 ? model.title : model.session_id
                }
                Label {
                    width: parent.width
                    font.pixelSize: Theme.fontSizeExtraSmall
                    color: Theme.secondaryColor
                    text: page.describe(model)
                }
            }
            onClicked: page.openSession(model.session_id)
        }
        ViewPlaceholder {
            enabled: api.sessions.length === 0 && !api.busy
            text: qsTr("No sessions")
            hintText: qsTr("Pull down to create a new session")
        }
        VerticalScrollDecorator {}
    }
    BusyIndicator {
        anchors.centerIn: parent
        size: BusyIndicatorSize.Large
        running: api.busy
    }
    Connections {
        target: api
        onLoggedInChanged: {
            if (!api.loggedIn)
                pageStack.replace(Qt.resolvedUrl("LoginPage.qml"))
        }
        onSessionOpened: {
            if (page.expectNewSession) {
                page.expectNewSession = false
                pageStack.push(Qt.resolvedUrl("ChatPage.qml"),
                               { sessionId: api.session.session_id })
            }
        }
    }
    Component.onCompleted: api.refreshSessions()
    function openSession(id) {
        expectNewSession = false
        pageStack.push(Qt.resolvedUrl("ChatPage.qml"), { sessionId: id })
    }
    function createSession() {
        expectNewSession = true
        chat.newSession()
    }
    function describe(m) {
        var n = m.message_count ? m.message_count : 0
        var d = new Date((m.updated_at ? m.updated_at : 0) * 1000)
        return n + qsTr(" messages") + " · " + Qt.formatDateTime(d, "dd/MM HH:mm")
    }
 }
@@ -0,0 +1,108 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 Page {
    id: page
    property var voiceNames: [
        "it-IT-ElsaNeural",
        "it-IT-DiegoNeural",
        "it-IT-IsabellaNeural",
        "it-IT-GiuseppeMultilingualNeural",
        "en-US-AriaNeural"
    ]
    property var engineNames: ["edge", "openai", "elevenlabs"]
    SilicaFlickable {
        anchors.fill: parent
        contentHeight: col.height + Theme.paddingLarge
        Column {
            id: col
            width: parent.width
            spacing: Theme.paddingMedium
            PageHeader { title: qsTr("Settings") }
            SectionHeader { text: qsTr("Server") }
            TextField {
                id: urlField
                width: parent.width
                label: qsTr("Web UI address")
                placeholderText: "https://hermes.example.com"
                inputMethodHints: Qt.ImhUrlCharactersOnly | Qt.ImhNoAutoUppercase
                onTextChanged: {
                    if (text !== appSettings.baseUrl)
                        appSettings.baseUrl = text
                }
            }
            SectionHeader { text: qsTr("Voice") }
            ComboBox {
                label: qsTr("Read-aloud voice")
                currentIndex: Math.max(0, page.voiceNames.indexOf(appSettings.ttsVoice))
                menu: ContextMenu {
                    Repeater {
                        model: page.voiceNames
                        MenuItem {
                            text: modelData
                            onClicked: appSettings.ttsVoice = modelData
                        }
                    }
                }
            }
            ComboBox {
                label: qsTr("TTS engine")
                currentIndex: Math.max(0, page.engineNames.indexOf(appSettings.ttsEngine))
                menu: ContextMenu {
                    Repeater {
                        model: page.engineNames
                        MenuItem {
                            text: modelData
                            onClicked: appSettings.ttsEngine = modelData
                        }
                    }
                }
            }
            TextSwitch {
                text: qsTr("Read replies aloud")
                description: qsTr("Speak every completed reply automatically")
                checked: appSettings.ttsAutoRead
                onCheckedChanged: appSettings.ttsAutoRead = checked
            }
            SectionHeader { text: qsTr("Account") }
            Button {
                anchors.horizontalCenter: parent.horizontalCenter
                text: qsTr("Sign out")
                onClicked: {
                    api.logout()
                    pageStack.replace(Qt.resolvedUrl("LoginPage.qml"))
                }
            }
            SectionHeader { text: qsTr("About") }
            Label {
                x: Theme.horizontalPageMargin
                width: parent.width - 2 * Theme.horizontalPageMargin
                wrapMode: Text.WordWrap
                font.pixelSize: Theme.fontSizeSmall
                color: Theme.secondaryColor
                text: "harbour-hermes " + appVersion + "\n\n" +
                      qsTr("Native client for the Hermes Web UI (hermes-webui): " +
                           "sessions, live streaming chat, server-side voice " +
                           "dictation and read-aloud.")
            }
        }
        VerticalScrollDecorator {}
    }
    Component.onCompleted: urlField.text = appSettings.baseUrl
 }
@@ -0,0 +1,41 @@
 import QtQuick 2.0
 import Sailfish.Silica 1.0
 // Avvio: verifica lo stato dell'autenticazione (cookie persistito) e
 // indirizza verso la lista sessioni o il login.
 Page {
    id: page
    Column {
        anchors.centerIn: parent
        spacing: Theme.paddingLarge
        width: parent.width - 2 * Theme.horizontalPageMargin
        Label {
            anchors.horizontalCenter: parent.horizontalCenter
            text: "Hermes"
            font.pixelSize: Theme.fontSizeHuge
            color: Theme.highlightColor
        }
        BusyIndicator {
            anchors.horizontalCenter: parent.horizontalCenter
            size: BusyIndicatorSize.Large
            running: true
        }
    }
    Connections {
        target: api
        onAuthChecked: page.route(loggedIn)
    }
    Component.onCompleted: api.checkAuth()
    function route(loggedIn) {
        if (loggedIn)
            pageStack.replace(Qt.resolvedUrl("SessionsPage.qml"))
        else
            pageStack.replace(Qt.resolvedUrl("LoginPage.qml"))
    }
 }
@@ -0,0 +1,22 @@
 [Desktop Entry]
 Name=Hermes
 Name[it_IT]=Hermes
 Comment=Client for the Hermes Web UI with voice
 Comment[it_IT]=Client per la Web UI di Hermes con voce
 Exec=harbour-hermes
 Icon=harbour-hermes
 Type=Application
 X-Nemo-Application-Type=silica-qt5
 Categories=Network;
 # Profilo SailJail esplicito: senza X-Sailjail la sandbox di Sailfish 5.1 usa il
 # profilo default, che nasconde ~/.config/harbour (config non persistente).
 # Org/App dichiarati QUI (letti dalla sandbox) e nel main.cpp (letti da
 # QStandardPaths): AppConfigLocation = ~/.config/harbour/hermes (persistente).
 # Internet = Web UI di Hermes (HTTPS). Microphone = dettatura vocale.
 # Audio = riproduzione delle risposte TTS e registrazione (PulseAudio non
 # separa i flussi: il permesso Audio copre entrambi).
 [X-Sailjail]
 Permissions=Internet;Audio;Microphone
 OrganizationName=harbour
 ApplicationName=hermes
@@ -0,0 +1,63 @@
 Name:       harbour-hermes
 Summary:    Client for the Hermes Web UI with voice
 Version:    0.1.0
 Release:    1
 Group:      Qt/Qt
 License:    MIT
 URL:        https://git.hackatoniclife.com/kaneda/harbour-hermes
 Source0:    %{name}-%{version}.tar.gz
 Source1:    %{name}.desktop
 Requires:   sailfishsilica-qt5 >= 0.10.9
 BuildRequires:  pkgconfig(sailfishapp) >= 1.0.2
 BuildRequires:  pkgconfig(Qt5Core)
 BuildRequires:  pkgconfig(Qt5Qml)
 BuildRequires:  pkgconfig(Qt5Quick)
 BuildRequires:  pkgconfig(Qt5Network)
 BuildRequires:  pkgconfig(Qt5Multimedia)
 BuildRequires:  desktop-file-utils
 %description
 Native Sailfish OS client for the Hermes Web UI (hermes-webui).
 Sessions list, chat with live streaming replies, voice dictation
 (server-side Whisper transcription) and read-aloud of replies
 (server-side TTS), plus a hands-free conversation mode.
 %changelog
 * Sat Sep 12 2026 Carlo Baratto <carlo@carlobaratto.it> - 0.1.0-1
 - Prima release: login alla Web UI di Hermes, lista sessioni,
  chat con streaming SSE, dettatura vocale (registrazione OGG/Opus
  -> /api/transcribe), lettura risposte (/api/tts -> QMediaPlayer),
  nuova sessione, sandbox SailJail (Internet;Audio;Microphone)
 %prep
 %setup -q -n %{name}-%{version}
 %build
 %qmake5
 make %{?_smp_mflags}
 %install
 make install INSTALL_ROOT=%{buildroot}
 mkdir -p %{buildroot}%{_datadir}/applications
 # Desktop file cercato in modo robusto: sfdk usa i sorgenti live (shadow build)
 # e la directory sorgente puo' chiamarsi %{name}-%{version} (tarball),
 # %{name} (clone) o %{name}-main (zip di Gitea); %{SOURCE1} e' il fallback.
 DESKTOP=$(find %{_builddir}/.. -maxdepth 4 -name '%{name}.desktop' 2>/dev/null | head -1)
 if [ -z "$DESKTOP" ] && [ -f %{SOURCE1} ]; then DESKTOP=%{SOURCE1}; fi
 if [ -z "$DESKTOP" ]; then
    echo "ERROR: %{name}.desktop not found" >&2
    exit 1
 fi
 install -m 0644 "$DESKTOP" %{buildroot}%{_datadir}/applications/%{name}.desktop
 desktop-file-validate %{buildroot}%{_datadir}/applications/%{name}.desktop || true
 %files
 %defattr(-,root,root,-)
 %{_bindir}/%{name}
 %{_datadir}/applications/%{name}.desktop
 %{_datadir}/icons/hicolor/86x86/apps/%{name}.png
 %{_datadir}/icons/hicolor/108x108/apps/%{name}.png
 %{_datadir}/icons/hicolor/128x128/apps/%{name}.png
 %{_datadir}/icons/hicolor/172x172/apps/%{name}.png
 %{_datadir}/%{name}/qml
@@ -0,0 +1,56 @@
 #!/usr/bin/env python3
 """Icone per harbour-hermes: bolla di chat con onde sonore, palette Nord.
 Uso: python3 scripts/make_icons.py [<output_dir>] [<name>]
 Scrive <out>/<size>x<size>/<name>.png per 86, 108, 128, 172.
 """
 import sys
 import os
 from PIL import Image, ImageDraw
 BG = (46, 52, 64)        # #2E3440
 ACCENT = (136, 192, 208) # #88C0D0
 PAGE = (229, 233, 240)   # #E5E9F0
 WAVE = (163, 190, 140)   # #A3BE8C
 def draw_icon(size):
    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
    d = ImageDraw.Draw(img)
    m = size * 0.05
    d.rounded_rectangle([m, m, size - m, size - m], radius=size * 0.16, fill=BG)
    # bolla di chat a sinistra
    bx0, by0 = size * 0.18, size * 0.26
    bx1, by1 = size * 0.56, size * 0.62
    d.rounded_rectangle([bx0, by0, bx1, by1], radius=size * 0.07, fill=PAGE)
    d.polygon([(size * 0.30, by1 - size * 0.01),
               (size * 0.20, size * 0.74),
               (size * 0.40, by1)], fill=PAGE)
    # onde sonore a destra (tre archi concentrici)
    cx, cy = size * 0.66, size * 0.585
    for i, rr in enumerate((0.085, 0.155, 0.225)):
        r = size * rr
        d.arc([cx - r, cy - r, cx + r, cy + r], 300, 60,
              fill=ACCENT if i < 2 else WAVE,
              width=max(2, int(size * 0.028)))
    # puntino sorgente
    pr = size * 0.035
    d.ellipse([cx - pr, cy - pr, cx + pr, cy + pr], fill=ACCENT)
    return img
 def main():
    out_dir = sys.argv[1] if len(sys.argv) > 1 else "icons"
    name = sys.argv[2] if len(sys.argv) > 2 else "harbour-hermes"
    for s in (86, 108, 128, 172):
        d = os.path.join(out_dir, "%dx%d" % (s, s))
        os.makedirs(d, exist_ok=True)
        draw_icon(s).save(os.path.join(d, name + ".png"))
    print("icone scritte in %s/ (86..172)" % out_dir)
 if __name__ == "__main__":
    main()
@@ -0,0 +1,505 @@
 #include "apiclient.h"
 #include <QDateTime>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QHttpMultiPart>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QStandardPaths>
 #include <QUrlQuery>
 ApiClient::ApiClient(Settings *settings, QObject *parent)
    : QObject(parent)
    , m_settings(settings)
    , m_jar(new CookieJar(this))
    , m_loggedIn(false)
    , m_busy(false)
    , m_streaming(false)
    , m_transcribing(false)
    , m_streamReply(nullptr)
    , m_streamEndedEmitted(false)
 {
    // Cookie di sessione persistente (0600), nella zona config della sandbox.
    const QString cfg = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
    QDir().mkpath(cfg);
    m_jar->setFilePath(cfg + QStringLiteral("/cookies.dat"));
    m_jar->load();
    m_nam.setCookieJar(m_jar);
 }
 // ---------------------------------------------------------------- helpers --
 QUrl ApiClient::apiUrl(const QString &path) const
 {
    return QUrl(m_settings->baseUrl() + path);
 }
 QNetworkRequest ApiClient::jsonRequest(const QString &path, bool post) const
 {
    Q_UNUSED(post)
    QNetworkRequest req(apiUrl(path));
    req.setHeader(QNetworkRequest::ContentTypeHeader,
                  QStringLiteral("application/json"));
    return req;
 }
 QString ApiClient::cacheDir(const QString &sub) const
 {
    const QString base = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    const QString dir = base + QStringLiteral("/") + sub;
    QDir().mkpath(dir);
    return dir;
 }
 QString ApiClient::errorFromReply(QNetworkReply *reply, const QByteArray &body) const
 {
    const QJsonDocument doc = QJsonDocument::fromJson(body);
    if (doc.isObject()) {
        const QString err = doc.object().value(QStringLiteral("error")).toString();
        if (!err.isEmpty())
            return err;
    }
    const int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    if (status == 401)
        return QStringLiteral("Authentication required");
    if (status > 0)
        return QStringLiteral("HTTP %1").arg(status);
    return reply->errorString();
 }
 void ApiClient::setBusy(bool on)
 {
    if (on == m_busy)
        return;
    m_busy = on;
    emit busyChanged();
 }
 void ApiClient::setStreaming(bool on)
 {
    if (on == m_streaming)
        return;
    m_streaming = on;
    emit streamingChanged();
 }
 void ApiClient::setTranscribing(bool on)
 {
    if (on == m_transcribing)
        return;
    m_transcribing = on;
    emit transcribingChanged();
 }
 void ApiClient::setLastError(const QString &error)
 {
    if (error == m_lastError)
        return;
    m_lastError = error;
    emit lastErrorChanged();
 }
 void ApiClient::setLoggedIn(bool on)
 {
    if (on == m_loggedIn)
        return;
    m_loggedIn = on;
    emit loggedInChanged();
 }
 void ApiClient::clearError()
 {
    setLastError(QString());
 }
 // ------------------------------------------------------------------- auth --
 void ApiClient::checkAuth()
 {
    QNetworkReply *reply = m_nam.get(jsonRequest(QStringLiteral("/api/auth/status")));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        const QByteArray body = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            setLoggedIn(false);
            emit authChecked(false);
            return;
        }
        const QJsonObject obj = QJsonDocument::fromJson(body).object();
        const bool authEnabled = obj.value(QStringLiteral("auth_enabled")).toBool();
        const bool sessionValid = obj.value(QStringLiteral("logged_in")).toBool();
        if (!authEnabled || sessionValid) {
            setLoggedIn(true);
            refreshSessions();
        } else {
            setLoggedIn(false);
        }
        emit authChecked(m_loggedIn);
    });
 }
 void ApiClient::login(const QString &password)
 {
    setLastError(QString());
    setBusy(true);
    QJsonObject body;
    body.insert(QStringLiteral("password"), password);
    QNetworkReply *reply = m_nam.post(jsonRequest(QStringLiteral("/api/auth/login")),
                                      QJsonDocument(body).toJson(QJsonDocument::Compact));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        setBusy(false);
        const QByteArray data = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            setLastError(errorFromReply(reply, data));
            return;
        }
        setLoggedIn(true);
        refreshSessions();
    });
 }
 void ApiClient::logout()
 {
    QNetworkReply *reply = m_nam.post(jsonRequest(QStringLiteral("/api/auth/logout")), QByteArray());
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
    });
    m_jar->clear();
    setLoggedIn(false);
    m_sessions.clear();
    emit sessionsChanged();
    m_session.clear();
    emit sessionChanged();
 }
 // --------------------------------------------------------------- sessioni --
 void ApiClient::refreshSessions()
 {
    setBusy(true);
    QNetworkReply *reply = m_nam.get(jsonRequest(QStringLiteral("/api/sessions")));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        setBusy(false);
        const QByteArray body = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            setLastError(errorFromReply(reply, body));
            return;
        }
        const QJsonObject obj = QJsonDocument::fromJson(body).object();
        const QJsonArray arr = obj.value(QStringLiteral("sessions")).toArray();
        m_sessions = arr.toVariantList();
        emit sessionsChanged();
    });
 }
 void ApiClient::openSession(const QString &id)
 {
    setLastError(QString());
    setBusy(true);
    QUrl url = apiUrl(QStringLiteral("/api/session"));
    QUrlQuery q;
    q.addQueryItem(QStringLiteral("session_id"), id);
    url.setQuery(q);
    QNetworkReply *reply = m_nam.get(QNetworkRequest(url));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        setBusy(false);
        const QByteArray body = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            setLastError(errorFromReply(reply, body));
            return;
        }
        const QJsonObject obj = QJsonDocument::fromJson(body).object();
        m_session = obj.value(QStringLiteral("session")).toObject().toVariantMap();
        emit sessionChanged();
        emit sessionOpened();
        // Se la sessione ha gia' un run attivo (ripresa dopo chiusura app),
        // riaggancia lo stream SSE.
        const QString active = m_session.value(QStringLiteral("active_stream_id")).toString();
        if (!active.isEmpty())
            startStream(active);
    });
 }
 void ApiClient::newSession()
 {
    setLastError(QString());
    setBusy(true);
    QJsonObject body;
    const QString ws = m_settings->defaultWorkspace();
    if (!ws.isEmpty())
        body.insert(QStringLiteral("workspace"), ws);
    QNetworkReply *reply = m_nam.post(jsonRequest(QStringLiteral("/api/session/new")),
                                      QJsonDocument(body).toJson(QJsonDocument::Compact));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        setBusy(false);
        const QByteArray data = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            setLastError(errorFromReply(reply, data));
            return;
        }
        const QJsonObject obj = QJsonDocument::fromJson(data).object();
        m_session = obj.value(QStringLiteral("session")).toObject().toVariantMap();
        emit sessionChanged();
        emit sessionOpened();
        refreshSessions();
    });
 }
 // ------------------------------------------------------------------- chat --
 void ApiClient::startChat(const QString &sessionId, const QString &message)
 {
    setLastError(QString());
    QJsonObject body;
    body.insert(QStringLiteral("session_id"), sessionId);
    body.insert(QStringLiteral("message"), message);
    const QString model = m_session.value(QStringLiteral("model")).toString();
    const QString provider = m_session.value(QStringLiteral("model_provider")).toString();
    const QString workspace = m_session.value(QStringLiteral("workspace")).toString();
    QString profile = m_session.value(QStringLiteral("profile")).toString();
    if (profile.isEmpty())
        profile = QStringLiteral("default");
    body.insert(QStringLiteral("model"), model);
    body.insert(QStringLiteral("model_provider"), provider);
    body.insert(QStringLiteral("workspace"), workspace);
    body.insert(QStringLiteral("profile"), profile);
    QNetworkReply *reply = m_nam.post(jsonRequest(QStringLiteral("/api/chat/start")),
                                      QJsonDocument(body).toJson(QJsonDocument::Compact));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        handleStartReply(reply);
    });
 }
 void ApiClient::handleStartReply(QNetworkReply *reply)
 {
    reply->deleteLater();
    const QByteArray body = reply->readAll();
    if (reply->error() != QNetworkReply::NoError) {
        const QString err = errorFromReply(reply, body);
        setLastError(err);
        emit chatStartFailed(err);
        return;
    }
    const QJsonObject obj = QJsonDocument::fromJson(body).object();
    const QString streamId = obj.value(QStringLiteral("stream_id")).toString();
    if (streamId.isEmpty()) {
        const QString err = QStringLiteral("No stream_id in response");
        setLastError(err);
        emit chatStartFailed(err);
        return;
    }
    const QString sid = obj.value(QStringLiteral("session_id")).toString();
    if (!sid.isEmpty())
        m_session.insert(QStringLiteral("session_id"), sid);
    emit chatStarted(streamId);
    startStream(streamId);
 }
 void ApiClient::cancelRun()
 {
    if (m_streamId.isEmpty())
        return;
    QUrl url = apiUrl(QStringLiteral("/api/chat/cancel"));
    QUrlQuery q;
    q.addQueryItem(QStringLiteral("stream_id"), m_streamId);
    url.setQuery(q);
    QNetworkReply *reply = m_nam.get(QNetworkRequest(url));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
    });
 }
 // -------------------------------------------------------------------- SSE --
 void ApiClient::startStream(const QString &streamId)
 {
    if (m_streamReply) {
        m_streamReply->abort();
        m_streamReply->deleteLater();
        m_streamReply = nullptr;
    }
    m_streamId = streamId;
    m_streamEndedEmitted = false;
    m_parser.reset();
    QUrl url = apiUrl(QStringLiteral("/api/chat/stream"));
    QUrlQuery q;
    q.addQueryItem(QStringLiteral("stream_id"), streamId);
    url.setQuery(q);
    QNetworkRequest req(url);
    req.setRawHeader("Accept", "text/event-stream");
    m_streamReply = m_nam.get(req);
    setStreaming(true);
    connect(m_streamReply, &QNetworkReply::readyRead, this, [this]() {
        if (!m_streamReply)
            return;
        const QList<SseParser::Event> events = m_parser.feed(m_streamReply->readAll());
        for (int i = 0; i < events.size(); ++i)
            dispatchSseEvent(events.at(i));
    });
    connect(m_streamReply, &QNetworkReply::finished, this, [this]() {
        QNetworkReply *reply = m_streamReply;
        m_streamReply = nullptr;
        if (reply) {
            if (reply->error() != QNetworkReply::NoError
                    && reply->error() != QNetworkReply::OperationCanceledError) {
                const QString err = reply->errorString();
                setLastError(err);
                emit streamError(err);
            }
            reply->deleteLater();
        }
        emitStreamEndedOnce();
        setStreaming(false);
    });
 }
 void ApiClient::dispatchSseEvent(const SseParser::Event &ev)
 {
    const QJsonObject obj = QJsonDocument::fromJson(ev.data.toUtf8()).object();
    if (ev.name == QLatin1String("token")) {
        emit streamDelta(obj.value(QStringLiteral("text")).toString());
    } else if (ev.name == QLatin1String("done")) {
        const QVariantMap session = obj.value(QStringLiteral("session")).toObject().toVariantMap();
        if (!session.isEmpty()) {
            m_session = session;
            emit sessionChanged();
        }
        emit streamDone(session);
    } else if (ev.name == QLatin1String("title")) {
        const QString title = obj.value(QStringLiteral("title")).toString();
        if (!title.isEmpty()) {
            m_session.insert(QStringLiteral("title"), title);
            emit sessionChanged();
            emit streamTitle(title);
        }
    } else if (ev.name == QLatin1String("stream_end")) {
        emitStreamEndedOnce();
    }
    // Altri eventi noti (context_status, metering, title_status) e sconosciuti:
    // ignorati intenzionalmente in questa versione.
 }
 void ApiClient::emitStreamEndedOnce()
 {
    if (m_streamEndedEmitted)
        return;
    m_streamEndedEmitted = true;
    emit streamEnded();
 }
 // ------------------------------------------------------------------- voce --
 void ApiClient::transcribeFile(const QString &path)
 {
    setLastError(QString());
    setTranscribing(true);
    QFile *file = new QFile(path);
    if (!file->open(QIODevice::ReadOnly)) {
        file->deleteLater();
        setTranscribing(false);
        const QString err = QStringLiteral("Cannot open audio file");
        setLastError(err);
        emit transcriptionFailed(err);
        return;
    }
    QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
    QHttpPart filePart;
    filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QStringLiteral("audio/ogg")));
    filePart.setHeader(QNetworkRequest::ContentDispositionHeader,
                       QVariant(QStringLiteral("form-data; name=\"file\"; filename=\"%1\"")
                                    .arg(QFileInfo(path).fileName())));
    filePart.setBodyDevice(file);
    file->setParent(multiPart);
    multiPart->append(filePart);
    QNetworkRequest req(apiUrl(QStringLiteral("/api/transcribe")));
    QNetworkReply *reply = m_nam.post(req, multiPart);
    multiPart->setParent(reply);
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        setTranscribing(false);
        const QByteArray body = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            const QString err = errorFromReply(reply, body);
            setLastError(err);
            emit transcriptionFailed(err);
            return;
        }
        const QJsonObject obj = QJsonDocument::fromJson(body).object();
        if (!obj.value(QStringLiteral("ok")).toBool()) {
            QString err = obj.value(QStringLiteral("error")).toString();
            if (err.isEmpty())
                err = QStringLiteral("Transcription failed");
            setLastError(err);
            emit transcriptionFailed(err);
            return;
        }
        emit transcriptionReady(obj.value(QStringLiteral("transcript")).toString().trimmed());
    });
 }
 void ApiClient::speak(const QString &text)
 {
    const QString trimmed = text.trimmed();
    if (trimmed.isEmpty())
        return;
    // Il server accetta max 5000 caratteri per richiesta: tronca con avviso.
    QString spoken = trimmed;
    if (spoken.size() > 4900)
        spoken = spoken.left(4900);
    setLastError(QString());
    QJsonObject body;
    body.insert(QStringLiteral("text"), spoken);
    body.insert(QStringLiteral("voice"), m_settings->ttsVoice());
    body.insert(QStringLiteral("engine"), m_settings->ttsEngine());
    QNetworkReply *reply = m_nam.post(jsonRequest(QStringLiteral("/api/tts")),
                                      QJsonDocument(body).toJson(QJsonDocument::Compact));
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        const QByteArray body = reply->readAll();
        if (reply->error() != QNetworkReply::NoError) {
            const QString err = errorFromReply(reply, body);
            setLastError(err);
            emit ttsFailed(err);
            return;
        }
        const QVariant contentType = reply->header(QNetworkRequest::ContentTypeHeader);
        if (!contentType.toString().startsWith(QLatin1String("audio/"))) {
            QString err = QStringLiteral("TTS returned non-audio response");
            const QJsonObject obj = QJsonDocument::fromJson(body).object();
            const QString jsonErr = obj.value(QStringLiteral("error")).toString();
            if (!jsonErr.isEmpty())
                err = jsonErr;
            setLastError(err);
            emit ttsFailed(err);
            return;
        }
        const QString file = cacheDir(QStringLiteral("tts"))
                + QStringLiteral("/reply-%1.mp3")
                      .arg(QDateTime::currentMSecsSinceEpoch());
        QFile f(file);
        if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
            const QString err = QStringLiteral("Cannot write audio file");
            setLastError(err);
            emit ttsFailed(err);
            return;
        }
        f.write(body);
        f.close();
        emit ttsReady(file);
    });
 }
@@ -0,0 +1,131 @@
 #ifndef APICLIENT_H
 #define APICLIENT_H
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QObject>
 #include <QVariantList>
 #include <QVariantMap>
 #include "cookiejar.h"
 #include "settings.h"
 #include "sseparser.h"
 class QHttpMultiPart;
 // Client HTTP per la Web UI di Hermes (hermes-webui).
 //
 // Protocollo (vedi docs/PROTOCOL.md, validato contro il server reale):
 //   POST /api/auth/login {password}                 -> cookie di sessione
 //   GET  /api/auth/status                           -> {auth_enabled, logged_in}
 //   GET  /api/sessions                              -> {sessions: [...]}
 //   GET  /api/session?session_id=ID                 -> {session: {...messages}}
 //   POST /api/session/new {workspace?}              -> {session: {...}}
 //   POST /api/chat/start {session_id, message, ...} -> {stream_id, ...}
 //   GET  /api/chat/stream?stream_id=ID              -> SSE (text/event-stream)
 //   GET  /api/chat/cancel?stream_id=ID              -> {ok, cancelled}
 //   POST /api/transcribe (multipart "file")         -> {ok, transcript}
 //   POST /api/tts {text, voice, engine}             -> audio/mpeg
 //
 // L'autenticazione e' a cookie: il jar e' persistente (CookieJar).
 class ApiClient : public QObject
 {
    Q_OBJECT
    Q_PROPERTY(bool loggedIn READ loggedIn NOTIFY loggedInChanged)
    Q_PROPERTY(bool busy READ busy NOTIFY busyChanged)
    Q_PROPERTY(bool streaming READ streaming NOTIFY streamingChanged)
    Q_PROPERTY(bool transcribing READ transcribing NOTIFY transcribingChanged)
    Q_PROPERTY(QString lastError READ lastError NOTIFY lastErrorChanged)
    Q_PROPERTY(QVariantList sessions READ sessions NOTIFY sessionsChanged)
    Q_PROPERTY(QVariantMap session READ session NOTIFY sessionChanged)
 public:
    explicit ApiClient(Settings *settings, QObject *parent = nullptr);
    bool loggedIn() const { return m_loggedIn; }
    bool busy() const { return m_busy; }
    bool streaming() const { return m_streaming; }
    bool transcribing() const { return m_transcribing; }
    QString lastError() const { return m_lastError; }
    QVariantList sessions() const { return m_sessions; }
    QVariantMap session() const { return m_session; }
    // Avvio: verifica lo stato auth (cookie persistito o auth disabilitata).
    Q_INVOKABLE void checkAuth();
    Q_INVOKABLE void login(const QString &password);
    Q_INVOKABLE void logout();
    Q_INVOKABLE void refreshSessions();
    Q_INVOKABLE void openSession(const QString &id);
    Q_INVOKABLE void newSession();
    // Avvia un turno e collega automaticamente lo stream SSE.
    Q_INVOKABLE void startChat(const QString &sessionId, const QString &message);
    Q_INVOKABLE void cancelRun();
    // Voce: trascrizione di un file audio (multipart) e sintesi TTS.
    Q_INVOKABLE void transcribeFile(const QString &path);
    Q_INVOKABLE void speak(const QString &text);
    Q_INVOKABLE void clearError();
 signals:
    void loggedInChanged();
    void busyChanged();
    void streamingChanged();
    void transcribingChanged();
    void lastErrorChanged();
    void sessionsChanged();
    void sessionChanged();
    void authChecked(bool loggedIn);
    void sessionOpened();                 // openSession/newSession completata
    void chatStarted(const QString &streamId);
    void chatStartFailed(const QString &error);
    void streamDelta(const QString &text);
    void streamDone(const QVariantMap &session);
    void streamTitle(const QString &title);
    void streamEnded();
    void streamError(const QString &error);
    void transcriptionReady(const QString &text);
    void transcriptionFailed(const QString &error);
    void ttsReady(const QString &filePath);
    void ttsFailed(const QString &error);
 private:
    void setBusy(bool on);
    void setStreaming(bool on);
    void setTranscribing(bool on);
    void setLastError(const QString &error);
    void setLoggedIn(bool on);
    QUrl apiUrl(const QString &path) const;
    QNetworkRequest jsonRequest(const QString &path, bool post = false) const;
    QString errorFromReply(QNetworkReply *reply, const QByteArray &body) const;
    QString cacheDir(const QString &sub) const;
    void startStream(const QString &streamId);
    void dispatchSseEvent(const SseParser::Event &ev);
    void emitStreamEndedOnce();
    void handleStartReply(QNetworkReply *reply);
    Settings *m_settings;
    QNetworkAccessManager m_nam;
    CookieJar *m_jar;
    bool m_loggedIn;
    bool m_busy;
    bool m_streaming;
    bool m_transcribing;
    QString m_lastError;
    QVariantList m_sessions;
    QVariantMap m_session;
    QString m_streamId;
    QNetworkReply *m_streamReply;
    SseParser m_parser;
    bool m_streamEndedEmitted;
 };
 #endif // APICLIENT_H
@@ -0,0 +1,252 @@
 #include "chatmodel.h"
 #include <QTimer>
 ChatModel::ChatModel(ApiClient *api, QObject *parent)
    : QAbstractListModel(parent)
    , m_api(api)
    , m_busy(false)
    , m_finalizedThisRun(false)
 {
    connect(m_api, &ApiClient::sessionOpened, this, &ChatModel::onSessionOpened);
    connect(m_api, &ApiClient::chatStarted, this, &ChatModel::onChatStarted);
    connect(m_api, &ApiClient::chatStartFailed, this, &ChatModel::onChatStartFailed);
    connect(m_api, &ApiClient::streamDelta, this, &ChatModel::onStreamDelta);
    connect(m_api, &ApiClient::streamDone, this, &ChatModel::onStreamDone);
    connect(m_api, &ApiClient::streamEnded, this, &ChatModel::onStreamEnded);
    connect(m_api, &ApiClient::streamError, this, &ChatModel::onStreamError);
 }
 int ChatModel::rowCount(const QModelIndex &parent) const
 {
    if (parent.isValid())
        return 0;
    return m_msgs.size();
 }
 QVariant ChatModel::data(const QModelIndex &index, int role) const
 {
    if (!index.isValid() || index.row() < 0 || index.row() >= m_msgs.size())
        return QVariant();
    const Msg &m = m_msgs.at(index.row());
    switch (role) {
    case RoleRole:
        return m.role;
    case ContentRole:
        return m.content;
    case StreamingRole:
        return m.streaming;
    case TimestampRole:
        return m.ts;
    default:
        return QVariant();
    }
 }
 QHash<int, QByteArray> ChatModel::roleNames() const
 {
    QHash<int, QByteArray> roles;
    roles.insert(RoleRole, "role");
    roles.insert(ContentRole, "content");
    roles.insert(StreamingRole, "streaming");
    roles.insert(TimestampRole, "timestamp");
    return roles;
 }
 // ------------------------------------------------------------ flusso chat --
 void ChatModel::openSession(const QString &id)
 {
    m_sessionId = id;
    m_title.clear();
    setFromMessages(QVariantList());
    emit sessionInfoChanged();
    m_api->openSession(id);
 }
 void ChatModel::newSession()
 {
    m_title.clear();
    setFromMessages(QVariantList());
    emit sessionInfoChanged();
    m_api->newSession();
 }
 void ChatModel::resync()
 {
    if (!m_sessionId.isEmpty())
        m_api->openSession(m_sessionId);
 }
 void ChatModel::send(const QString &text)
 {
    const QString trimmed = text.trimmed();
    if (trimmed.isEmpty() || m_sessionId.isEmpty() || m_busy)
        return;
    m_finalizedThisRun = false;
    appendMessage(QStringLiteral("user"), trimmed, false);
    beginAssistant();
    setBusy(true);
    m_api->startChat(m_sessionId, trimmed);
 }
 void ChatModel::cancel()
 {
    m_api->cancelRun();
 }
 QString ChatModel::lastAssistantText() const
 {
    for (int i = m_msgs.size() - 1; i >= 0; --i) {
        const Msg &m = m_msgs.at(i);
        if (m.role == QLatin1String("assistant") && !m.content.trimmed().isEmpty())
            return m.content;
    }
    return QString();
 }
 void ChatModel::onSessionOpened()
 {
    const QVariantMap s = m_api->session();
    const QString sid = s.value(QStringLiteral("session_id")).toString();
    if (!sid.isEmpty())
        m_sessionId = sid;
    m_title = s.value(QStringLiteral("title")).toString();
    setFromMessages(s.value(QStringLiteral("messages")).toList());
    emit sessionInfoChanged();
    // Ripresa: la sessione aveva un run attivo e lo stream e' stato riagganciato.
    if (m_api->streaming()) {
        beginAssistant();
        setBusy(true);
    }
 }
 void ChatModel::onChatStarted(const QString &streamId)
 {
    Q_UNUSED(streamId)
    if (m_msgs.isEmpty() || m_msgs.last().role != QLatin1String("assistant"))
        beginAssistant();
    setBusy(true);
 }
 void ChatModel::onChatStartFailed(const QString &error)
 {
    // Rimuove il placeholder assistente rimasto vuoto.
    if (m_msgs.size() > 0 && m_msgs.last().role == QLatin1String("assistant")
            && m_msgs.last().content.isEmpty()) {
        beginRemoveRows(QModelIndex(), m_msgs.size() - 1, m_msgs.size() - 1);
        m_msgs.removeLast();
        endRemoveRows();
        emit rowCountChanged();
    }
    setBusy(false);
    emit notice(error);
 }
 void ChatModel::onStreamDelta(const QString &text)
 {
    if (m_msgs.isEmpty() || m_msgs.last().role != QLatin1String("assistant"))
        beginAssistant();
    Msg &last = m_msgs.last();
    if (!last.streaming) {
        last.streaming = true;
    }
    last.content += text;
    const QModelIndex idx = index(m_msgs.size() - 1, 0);
    emit dataChanged(idx, idx, QVector<int>() << ContentRole << StreamingRole);
    emit streamTick();
 }
 void ChatModel::onStreamDone(const QVariantMap &session)
 {
    m_finalizedThisRun = true;
    m_title = session.value(QStringLiteral("title")).toString();
    setFromMessages(session.value(QStringLiteral("messages")).toList());
    emit sessionInfoChanged();
    setBusy(false);
    emit assistantFinished();
 }
 void ChatModel::onStreamEnded()
 {
    if (!m_msgs.isEmpty() && m_msgs.last().streaming) {
        Msg &last = m_msgs.last();
        last.streaming = false;
        // Placeholder rimasto vuoto (run interrotto prima del primo token).
        if (last.role == QLatin1String("assistant") && last.content.isEmpty()) {
            beginRemoveRows(QModelIndex(), m_msgs.size() - 1, m_msgs.size() - 1);
            m_msgs.removeLast();
            endRemoveRows();
            emit rowCountChanged();
        } else {
            const QModelIndex idx = index(m_msgs.size() - 1, 0);
            emit dataChanged(idx, idx, QVector<int>() << StreamingRole);
        }
    }
    setBusy(false);
    // Aggiorna la lista sessioni (titolo/ordinamento possono essere cambiati).
    m_api->refreshSessions();
 }
 void ChatModel::onStreamError(const QString &error)
 {
    emit notice(error);
    // Lo stream puo' cadere per sospensione dell'app: risincronizza dallo stato
    // del server tra un attimo (se nel frattempo non e' gia' ripartito qualcosa).
    QTimer::singleShot(1200, this, [this]() {
        if (!m_api->streaming() && !m_sessionId.isEmpty())
            m_api->openSession(m_sessionId);
    });
 }
 // ------------------------------------------------------------- modello ----
 void ChatModel::setFromMessages(const QVariantList &messages)
 {
    beginResetModel();
    m_msgs.clear();
    for (int i = 0; i < messages.size(); ++i) {
        const QVariantMap m = messages.at(i).toMap();
        const QString role = m.value(QStringLiteral("role")).toString();
        if (role != QLatin1String("user") && role != QLatin1String("assistant"))
            continue;
        const QString content = m.value(QStringLiteral("content")).toString();
        // Messaggi assistente vuoti (solo chiamate a strumenti): non mostrati.
        if (role == QLatin1String("assistant") && content.trimmed().isEmpty())
            continue;
        Msg msg;
        msg.role = role;
        msg.content = content;
        msg.streaming = false;
        msg.ts = m.value(QStringLiteral("timestamp")).toDouble();
        m_msgs.append(msg);
    }
    endResetModel();
    emit rowCountChanged();
 }
 void ChatModel::appendMessage(const QString &role, const QString &content, bool streaming)
 {
    beginInsertRows(QModelIndex(), m_msgs.size(), m_msgs.size());
    Msg msg;
    msg.role = role;
    msg.content = content;
    msg.streaming = streaming;
    msg.ts = 0;
    m_msgs.append(msg);
    endInsertRows();
    emit rowCountChanged();
 }
 void ChatModel::beginAssistant()
 {
    appendMessage(QStringLiteral("assistant"), QString(), true);
 }
 void ChatModel::setBusy(bool on)
 {
    if (on == m_busy)
        return;
    m_busy = on;
    emit busyChanged();
 }
@@ -0,0 +1,93 @@
 #ifndef CHATMODEL_H
 #define CHATMODEL_H
 #include <QAbstractListModel>
 #include <QHash>
 #include <QList>
 #include <QString>
 #include <QVariantList>
 #include <QVariantMap>
 #include "apiclient.h"
 // Modello della conversazione corrente + orchestrazione del flusso chat.
 //
 // Riceve gli eventi da ApiClient e mantiene la lista messaggi per la UI:
 //   - apertura/nuova sessione -> reset dal JSON della sessione
 //   - invio -> messaggio utente ottimistico + placeholder assistente
 //   - streaming -> append dei delta "token"
 //   - done -> risincronizzazione con i messaggi finali della sessione
 class ChatModel : public QAbstractListModel
 {
    Q_OBJECT
    Q_PROPERTY(QString sessionId READ sessionId NOTIFY sessionInfoChanged)
    Q_PROPERTY(QString title READ title NOTIFY sessionInfoChanged)
    Q_PROPERTY(bool busy READ busy NOTIFY busyChanged)
    Q_PROPERTY(bool canSend READ canSend NOTIFY busyChanged)
    Q_PROPERTY(int count READ count NOTIFY rowCountChanged)
 public:
    enum Roles {
        RoleRole = Qt::UserRole + 1,
        ContentRole,
        StreamingRole,
        TimestampRole
    };
    explicit ChatModel(ApiClient *api, QObject *parent = nullptr);
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role) const override;
    QHash<int, QByteArray> roleNames() const override;
    QString sessionId() const { return m_sessionId; }
    QString title() const { return m_title; }
    bool busy() const { return m_busy; }
    bool canSend() const { return !m_busy && !m_sessionId.isEmpty(); }
    int count() const { return m_msgs.size(); }
    Q_INVOKABLE void openSession(const QString &id);
    Q_INVOKABLE void newSession();
    Q_INVOKABLE void send(const QString &text);
    Q_INVOKABLE void cancel();
    Q_INVOKABLE void resync();
    Q_INVOKABLE QString lastAssistantText() const;
 signals:
    void sessionInfoChanged();
    void busyChanged();
    void rowCountChanged();
    void streamTick();                 // ogni delta di streaming (per l'auto-scroll)
    void assistantFinished();          // risposta completata (per auto-read TTS)
    void notice(const QString &text);  // avvisi non bloccanti per la UI
 private:
    struct Msg {
        QString role;
        QString content;
        bool streaming;
        double ts;
    };
    void setFromMessages(const QVariantList &messages);
    void appendMessage(const QString &role, const QString &content, bool streaming);
    void beginAssistant();
    void setBusy(bool on);
    void onSessionOpened();
    void onChatStarted(const QString &streamId);
    void onChatStartFailed(const QString &error);
    void onStreamDelta(const QString &text);
    void onStreamDone(const QVariantMap &session);
    void onStreamEnded();
    void onStreamError(const QString &error);
    ApiClient *m_api;
    QList<Msg> m_msgs;
    QString m_sessionId;
    QString m_title;
    bool m_busy;
    bool m_finalizedThisRun;
 };
 #endif // CHATMODEL_H
@@ -0,0 +1,72 @@
 #include "cookiejar.h"
 #include <QFile>
 #include <QDir>
 #include <QFileInfo>
 #include <QNetworkCookie>
 CookieJar::CookieJar(QObject *parent)
    : QNetworkCookieJar(parent)
 {
 }
 void CookieJar::setFilePath(const QString &path)
 {
    m_path = path;
 }
 QString CookieJar::filePath() const
 {
    return m_path;
 }
 bool CookieJar::load()
 {
    if (m_path.isEmpty())
        return false;
    QFile f(m_path);
    if (!f.open(QIODevice::ReadOnly))
        return false;
    const QByteArray data = f.readAll();
    f.close();
    const QList<QNetworkCookie> cookies = QNetworkCookie::parseCookies(data);
    if (cookies.isEmpty())
        return false;
    setAllCookies(cookies);
    return true;
 }
 bool CookieJar::save() const
 {
    if (m_path.isEmpty())
        return false;
    const QFileInfo info(m_path);
    QDir().mkpath(info.absolutePath());
    QFile f(m_path);
    if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return false;
    // Permessi solo proprietario PRIMA di scrivere il contenuto.
    f.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner);
    const QList<QNetworkCookie> cookies = allCookies();
    for (int i = 0; i < cookies.size(); ++i) {
        f.write(cookies.at(i).toRawForm(QNetworkCookie::Full));
        f.write("\n");
    }
    f.close();
    return true;
 }
 void CookieJar::clear()
 {
    setAllCookies(QList<QNetworkCookie>());
    if (!m_path.isEmpty())
        QFile::remove(m_path);
 }
 bool CookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)
 {
    const bool changed = QNetworkCookieJar::setCookiesFromUrl(cookieList, url);
    if (changed)
        save();
    return changed;
 }
@@ -0,0 +1,31 @@
 #ifndef COOKIEJAR_H
 #define COOKIEJAR_H
 #include <QNetworkCookie>
 #include <QNetworkCookieJar>
 #include <QString>
 // Cookie jar persistente su file (0600).
 // Il cookie di sessione del WebUI di Hermes e' una credenziale: vive solo in
 // ~/.config/harbour/hermes/cookies.dat con permessi del solo proprietario.
 // Il salvataggio avviene automaticamente a ogni inserimento di cookie.
 class CookieJar : public QNetworkCookieJar
 {
 public:
    explicit CookieJar(QObject *parent = nullptr);
    void setFilePath(const QString &path);
    QString filePath() const;
    bool load();
    bool save() const;
    void clear();
 protected:
    bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url) override;
 private:
    QString m_path;
 };
 #endif // COOKIEJAR_H
@@ -0,0 +1,48 @@
 #include <QGuiApplication>
 #include <QQmlContext>
 #include <QQuickView>
 #include <QDebug>
 #include <sailfishapp.h>
 #include "apiclient.h"
 #include "chatmodel.h"
 #include "player.h"
 #include "recorder.h"
 #include "settings.h"
 Q_DECL_EXPORT int main(int argc, char *argv[])
 {
    QGuiApplication *app = SailfishApp::application(argc, argv);
    // Identita' allineata al profilo X-Sailjail del desktop file:
    // AppConfigLocation = ~/.config/harbour/hermes (zona persistente della sandbox).
    app->setOrganizationName(QStringLiteral("harbour"));
    app->setApplicationName(QStringLiteral("hermes"));
    app->setApplicationVersion(QStringLiteral("0.1.0"));
    qDebug() << "harbour-hermes v0.1.0 build" << __DATE__ << __TIME__;
    Settings settings;
    ApiClient api(&settings);
    ChatModel chat(&api);
    Recorder recorder;
    Player player;
    // Flusso voce: registrazione -> trascrizione; TTS pronto -> riproduzione.
    QObject::connect(&recorder, &Recorder::finished, &api, &ApiClient::transcribeFile);
    QObject::connect(&api, &ApiClient::ttsReady, &player, &Player::play);
    QQuickView *view = SailfishApp::createView();
    view->rootContext()->setContextProperty(QStringLiteral("appSettings"), &settings);
    view->rootContext()->setContextProperty(QStringLiteral("api"), &api);
    view->rootContext()->setContextProperty(QStringLiteral("chat"), &chat);
    view->rootContext()->setContextProperty(QStringLiteral("recorder"), &recorder);
    view->rootContext()->setContextProperty(QStringLiteral("player"), &player);
    view->rootContext()->setContextProperty(QStringLiteral("appVersion"),
                                            QCoreApplication::applicationVersion());
    view->setSource(SailfishApp::pathTo(QStringLiteral("qml/harbour-hermes.qml")));
    view->show();
    return app->exec();
 }
@@ -0,0 +1,39 @@
 #include "player.h"
 #include <QMediaContent>
 #include <QUrl>
 Player::Player(QObject *parent)
    : QObject(parent)
 {
    connect(&m_player, &QMediaPlayer::stateChanged, this,
            [this](QMediaPlayer::State) { emit playingChanged(); });
    connect(&m_player, &QMediaPlayer::mediaStatusChanged, this,
            [this](QMediaPlayer::MediaStatus status) {
                if (status == QMediaPlayer::EndOfMedia
                        || status == QMediaPlayer::InvalidMedia) {
                    emit playingChanged();
                    emit finished();
                }
            });
 }
 bool Player::playing() const
 {
    return m_player.state() == QMediaPlayer::PlayingState;
 }
 void Player::play(const QString &path)
 {
    stop();
    m_player.setMedia(QMediaContent(QUrl::fromLocalFile(path)));
    m_player.play();
    emit playingChanged();
 }
 void Player::stop()
 {
    if (m_player.state() != QMediaPlayer::StoppedState)
        m_player.stop();
    emit playingChanged();
 }
@@ -0,0 +1,31 @@
 #ifndef PLAYER_H
 #define PLAYER_H
 #include <QMediaPlayer>
 #include <QObject>
 #include <QString>
 // Riproduttore audio per le risposte TTS (QMediaPlayer, mp3 dal server).
 // L'output passa da PulseAudio; il volume segue il sistema.
 class Player : public QObject
 {
    Q_OBJECT
    Q_PROPERTY(bool playing READ playing NOTIFY playingChanged)
 public:
    explicit Player(QObject *parent = nullptr);
    bool playing() const;
    Q_INVOKABLE void play(const QString &path);
    Q_INVOKABLE void stop();
 signals:
    void playingChanged();
    void finished();
 private:
    QMediaPlayer m_player;
 };
 #endif // PLAYER_H
@@ -0,0 +1,143 @@
 #include "recorder.h"
 #include <QAudioEncoderSettings>
 #include <QAudioRecorder>
 #include <QDateTime>
 #include <QDir>
 #include <QStandardPaths>
 #include <QUrl>
 #include <QVideoEncoderSettings>
 namespace {
 // Container preferito: OGG; ripiego WAV.
 QString chooseContainer(const QStringList &containers)
 {
    if (containers.contains(QStringLiteral("audio/ogg")))
        return QStringLiteral("audio/ogg");
    if (containers.contains(QStringLiteral("audio/x-wav")))
        return QStringLiteral("audio/x-wav");
    return containers.isEmpty() ? QString() : containers.first();
 }
 // Codec preferito: Opus, poi Vorbis, poi PCM.
 QString chooseCodec(const QStringList &codecs)
 {
    if (codecs.contains(QStringLiteral("audio/opus")))
        return QStringLiteral("audio/opus");
    if (codecs.contains(QStringLiteral("audio/vorbis")))
        return QStringLiteral("audio/vorbis");
    if (codecs.contains(QStringLiteral("audio/pcm")))
        return QStringLiteral("audio/pcm");
    return codecs.isEmpty() ? QString() : codecs.first();
 }
 } // namespace
 Recorder::Recorder(QObject *parent)
    : QObject(parent)
    , m_rec(new QAudioRecorder(this))
    , m_stopping(false)
    , m_fallbackTried(false)
 {
    connect(m_rec,
            static_cast<void (QAudioRecorder::*)(QMediaRecorder::State)>(&QAudioRecorder::stateChanged),
            this, [this](QMediaRecorder::State) { onStateChanged(); });
    connect(m_rec,
            static_cast<void (QAudioRecorder::*)(QMediaRecorder::Error)>(&QAudioRecorder::error),
            this, [this](QMediaRecorder::Error) { onError(); });
    m_tick.setInterval(250);
    connect(&m_tick, &QTimer::timeout, this, [this]() { emit durationChanged(); });
 }
 bool Recorder::recording() const
 {
    return m_rec->state() == QMediaRecorder::RecordingState;
 }
 int Recorder::durationMs() const
 {
    return static_cast<int>(m_rec->duration());
 }
 bool Recorder::start()
 {
    if (recording())
        return true;
    const QString container = chooseContainer(m_rec->supportedContainers());
    const QString codec = chooseCodec(m_rec->supportedAudioCodecs());
    if (container.isEmpty() || codec.isEmpty()) {
        emit failed(QStringLiteral("No audio format available"));
        return false;
    }
    m_fallbackTried = false;
    return beginRecording(container, codec);
 }
 void Recorder::stop()
 {
    if (!recording())
        return;
    m_stopping = true;
    m_rec->stop();
 }
 bool Recorder::beginRecording(const QString &container, const QString &codec)
 {
    const QString base = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    const QString dir = base + QStringLiteral("/rec");
    QDir().mkpath(dir);
    const QString ext = container == QLatin1String("audio/x-wav") ? QStringLiteral(".wav")
                                                                  : QStringLiteral(".ogg");
    m_path = dir + QStringLiteral("/rec-%1%2")
                        .arg(QDateTime::currentMSecsSinceEpoch())
                        .arg(ext);
    m_container = container;
    QAudioEncoderSettings enc;
    enc.setCodec(codec);
    enc.setSampleRate(16000);
    enc.setChannelCount(1);
    enc.setQuality(QMultimedia::NormalQuality);
    m_rec->setEncodingSettings(enc, QVideoEncoderSettings(), container);
    m_rec->setOutputLocation(QUrl::fromLocalFile(m_path));
    m_stopping = false;
    m_rec->record();
    return true;
 }
 void Recorder::onStateChanged()
 {
    const bool rec = recording();
    if (rec)
        m_tick.start();
    else
        m_tick.stop();
    emit recordingChanged();
    emit durationChanged();
    if (!rec && m_stopping) {
        m_stopping = false;
        if (m_path.isEmpty())
            return;
        emit finished(m_path);
    }
 }
 void Recorder::onError()
 {
    // Primo tentativo fallito (es. codec non disponibile nel target):
    // un solo ritentativo con WAV/PCM, poi si arrende.
    if (!m_fallbackTried && !m_path.isEmpty()) {
        m_fallbackTried = true;
        m_rec->stop();
        if (beginRecording(QStringLiteral("audio/x-wav"), QStringLiteral("audio/pcm")))
            return;
    }
    m_tick.stop();
    emit recordingChanged();
    emit failed(m_rec->errorString());
 }
@@ -0,0 +1,51 @@
 #ifndef RECORDER_H
 #define RECORDER_H
 #include <QObject>
 #include <QString>
 #include <QStringList>
 #include <QTimer>
 class QAudioRecorder;
 // Registratore vocale (QAudioRecorder) con fallback di formato:
 // container/codec preferiti OGG/Opus, poi OGG/Vorbis, poi WAV/PCM.
 // Se il primo tentativo fallisce a runtime (codec assente nel target),
 // riprova una volta con WAV/PCM.
 // I file finiscono in <AppData>/rec/ (zona dati della sandbox SailJail).
 // Il permesso Microphone e' dichiarato nel profilo X-Sailjail del desktop file.
 class Recorder : public QObject
 {
    Q_OBJECT
    Q_PROPERTY(bool recording READ recording NOTIFY recordingChanged)
    Q_PROPERTY(int durationMs READ durationMs NOTIFY durationChanged)
 public:
    explicit Recorder(QObject *parent = nullptr);
    bool recording() const;
    int durationMs() const;
    Q_INVOKABLE bool start();
    Q_INVOKABLE void stop();
 signals:
    void recordingChanged();
    void durationChanged();
    void finished(const QString &path);   // file pronto per la trascrizione
    void failed(const QString &error);
 private:
    void onStateChanged();
    void onError();
    bool beginRecording(const QString &container, const QString &codec);
    QAudioRecorder *m_rec;
    QTimer m_tick;
    QString m_path;
    QString m_container;
    bool m_stopping;
    bool m_fallbackTried;
 };
 #endif // RECORDER_H
@@ -0,0 +1,84 @@
 #include "settings.h"
 // Default: l'istanza pubblica del WebUI usa questo host (HTTPS, cert valido).
 // L'utente puo' cambiarlo dalle impostazioni (LAN, VPN, altro dominio).
 static const char *kDefaultBaseUrl = "https://hermes.hackatoniclife.com";
 static const char *kDefaultTtsVoice = "it-IT-ElsaNeural";
 static const char *kDefaultTtsEngine = "edge";
 Settings::Settings(QObject *parent)
    : QObject(parent)
 {
 }
 QString Settings::baseUrl() const
 {
    QString v = m_settings.value(QStringLiteral("baseUrl"), QString::fromLatin1(kDefaultBaseUrl)).toString();
    // Normalizza: niente slash finale (componiamo gli URL con path assoluti).
    while (v.endsWith(QLatin1Char('/')))
        v.chop(1);
    return v;
 }
 void Settings::setBaseUrl(const QString &url)
 {
    QString v = url.trimmed();
    while (v.endsWith(QLatin1Char('/')))
        v.chop(1);
    if (v == baseUrl())
        return;
    m_settings.setValue(QStringLiteral("baseUrl"), v);
    emit baseUrlChanged();
 }
 QString Settings::ttsVoice() const
 {
    return m_settings.value(QStringLiteral("ttsVoice"), QString::fromLatin1(kDefaultTtsVoice)).toString();
 }
 void Settings::setTtsVoice(const QString &voice)
 {
    if (voice == ttsVoice())
        return;
    m_settings.setValue(QStringLiteral("ttsVoice"), voice);
    emit ttsVoiceChanged();
 }
 QString Settings::ttsEngine() const
 {
    return m_settings.value(QStringLiteral("ttsEngine"), QString::fromLatin1(kDefaultTtsEngine)).toString();
 }
 void Settings::setTtsEngine(const QString &engine)
 {
    if (engine == ttsEngine())
        return;
    m_settings.setValue(QStringLiteral("ttsEngine"), engine);
    emit ttsEngineChanged();
 }
 bool Settings::ttsAutoRead() const
 {
    return m_settings.value(QStringLiteral("ttsAutoRead"), false).toBool();
 }
 void Settings::setTtsAutoRead(bool on)
 {
    if (on == ttsAutoRead())
        return;
    m_settings.setValue(QStringLiteral("ttsAutoRead"), on);
    emit ttsAutoReadChanged();
 }
 QString Settings::defaultWorkspace() const
 {
    return m_settings.value(QStringLiteral("defaultWorkspace"), QString()).toString();
 }
 void Settings::setDefaultWorkspace(const QString &ws)
 {
    if (ws == defaultWorkspace())
        return;
    m_settings.setValue(QStringLiteral("defaultWorkspace"), ws);
    emit defaultWorkspaceChanged();
 }
@@ -0,0 +1,54 @@
 #ifndef SETTINGS_H
 #define SETTINGS_H
 #include <QObject>
 #include <QSettings>
 #include <QString>
 // Impostazioni persistenti dell'app.
 // QSettings con OrganizationName "harbour" / ApplicationName "hermes" (impostati
 // in main.cpp, allineati al profilo X-Sailjail del desktop file): file in
 // ~/.config/harbour/hermes.conf (zona persistente della sandbox).
 //
 // La password NON viene mai salvata: l'autenticazione si basa sul cookie di
 // sessione persistito in modo protetto (vedi CookieJar).
 class Settings : public QObject
 {
    Q_OBJECT
    Q_PROPERTY(QString baseUrl READ baseUrl WRITE setBaseUrl NOTIFY baseUrlChanged)
    Q_PROPERTY(QString ttsVoice READ ttsVoice WRITE setTtsVoice NOTIFY ttsVoiceChanged)
    Q_PROPERTY(QString ttsEngine READ ttsEngine WRITE setTtsEngine NOTIFY ttsEngineChanged)
    Q_PROPERTY(bool ttsAutoRead READ ttsAutoRead WRITE setTtsAutoRead NOTIFY ttsAutoReadChanged)
    Q_PROPERTY(QString defaultWorkspace READ defaultWorkspace WRITE setDefaultWorkspace
               NOTIFY defaultWorkspaceChanged)
 public:
    explicit Settings(QObject *parent = nullptr);
    QString baseUrl() const;
    void setBaseUrl(const QString &url);
    QString ttsVoice() const;
    void setTtsVoice(const QString &voice);
    QString ttsEngine() const;
    void setTtsEngine(const QString &engine);
    bool ttsAutoRead() const;
    void setTtsAutoRead(bool on);
    QString defaultWorkspace() const;
    void setDefaultWorkspace(const QString &ws);
 signals:
    void baseUrlChanged();
    void ttsVoiceChanged();
    void ttsEngineChanged();
    void ttsAutoReadChanged();
    void defaultWorkspaceChanged();
 private:
    QSettings m_settings;
 };
 #endif // SETTINGS_H
@@ -0,0 +1,59 @@
 #include "sseparser.h"
 SseParser::SseParser()
 {
 }
 QList<SseParser::Event> SseParser::feed(const QByteArray &chunk)
 {
    m_buffer += chunk;
    // Normalizza le terminazioni di riga (il server usa \n, ma per sicurezza).
    if (m_buffer.contains('\r'))
        m_buffer.replace("\r\n", "\n");
    QList<Event> events;
    int idx = -1;
    while ((idx = m_buffer.indexOf("\n\n")) >= 0) {
        const QByteArray block = m_buffer.left(idx);
        m_buffer.remove(0, idx + 2);
        Event ev;
        bool hasData = false;
        const QList<QByteArray> lines = block.split('\n');
        for (int i = 0; i < lines.size(); ++i) {
            const QByteArray &line = lines.at(i);
            if (line.isEmpty() || line.startsWith(':'))
                continue; // riga vuota o commento/keepalive
            if (line.startsWith("event:")) {
                ev.name = QString::fromUtf8(line.mid(6)).trimmed();
            } else if (line.startsWith("data:")) {
                QString d = QString::fromUtf8(line.mid(5));
                if (d.startsWith(QLatin1Char(' ')))
                    d.remove(0, 1);
                if (hasData)
                    ev.data += QLatin1Char('\n');
                ev.data += d;
                hasData = true;
            } else if (line.startsWith("id:")) {
                ev.id = QString::fromUtf8(line.mid(3)).trimmed();
            }
        }
        // Blocco di soli commenti/keepalive: niente da consegnare.
        if (!hasData)
            continue;
        if (ev.name.isEmpty())
            ev.name = QStringLiteral("message");
        events.append(ev);
    }
    return events;
 }
 void SseParser::reset()
 {
    m_buffer.clear();
 }
 QByteArray SseParser::pending() const
 {
    return m_buffer;
 }
@@ -0,0 +1,40 @@
 #ifndef SSEPARSER_H
 #define SSEPARSER_H
 #include <QByteArray>
 #include <QList>
 #include <QString>
 // Parser incrementale di Server-Sent Events (text/event-stream).
 //
 // Il WebUI di Hermes emette eventi nella forma:
 //   id: <stream_id>:<seq>
 //   event: token
 //   data: {"text": "..."}
 //   <riga vuota>
 // piu' commenti di keepalive (": heartbeat") da ignorare.
 //
 // Logica pura, senza dipendenze da rete: alimentato con i chunk grezzi,
 // restituisce gli eventi completi. Testabile in locale (tests/sse_test.cpp).
 class SseParser
 {
 public:
    struct Event {
        QString name;   // campo "event:" (vuoto => "message" SSE standard)
        QString data;   // campi "data:" concatenati con "\n"
        QString id;     // campo "id:" (cursore per replay)
    };
    SseParser();
    // Aggiunge un chunk e restituisce tutti gli eventi completati.
    QList<Event> feed(const QByteArray &chunk);
    void reset();
    QByteArray pending() const;
 private:
    QByteArray m_buffer;
 };
 #endif // SSEPARSER_H
@@ -0,0 +1,166 @@
 // Test locale del core di harbour-hermes (compilato con Qt desktop).
 //
 // Uso:
 //   ./core-test          -> solo unit test del parser SSE
 //   ./core-test --live   -> integrazione completa contro l'istanza di prova
 //                           del WebUI su http://127.0.0.1:8899
 //                           (login -> nuova sessione -> turno -> TTS -> STT)
 //
 // Il test live legge la password di prova da /tmp/hermes-probe/pw e usa
 // l'audio di prova /tmp/hermes-probe/out/prova.ogg.
 #include <QCoreApplication>
 #include <QDebug>
 #include <QFile>
 #include <QTimer>
 #include "apiclient.h"
 #include "chatmodel.h"
 #include "settings.h"
 #include "sseparser.h"
 static int failures = 0;
 #define CHECK(cond, msg)                            \
    do {                                            \
        if (!(cond)) {                              \
            qWarning() << "FAIL:" << msg;           \
            ++failures;                             \
        } else {                                    \
            qDebug() << "ok  :" << msg;             \
        }                                           \
    } while (0)
 static void testParser()
 {
    qDebug() << "== unit: parser SSE ==";
    const QByteArray sample =
        "id: s1:1\n"
        "event: context_status\n"
        "data: {\"a\": 1}\n"
        "\n"
        ": heartbeat\n"
        "\n"
        "id: s1:2\n"
        "event: token\n"
        "data: {\"text\": \"p\"}\n"
        "\n";
    SseParser p;
    const QList<SseParser::Event> evs = p.feed(sample);
    CHECK(evs.size() == 2, "due eventi, keepalive ignorato");
    if (evs.size() == 2) {
        CHECK(evs.at(0).name == QLatin1String("context_status"), "primo evento context_status");
        CHECK(evs.at(0).id == QLatin1String("s1:1"), "id del primo evento");
        CHECK(evs.at(1).name == QLatin1String("token"), "secondo evento token");
        CHECK(evs.at(1).data == QLatin1String("{\"text\": \"p\"}"), "data del token");
    }
    // Chunk spezzati a meta' evento (caso reale della rete).
    SseParser p2;
    CHECK(p2.feed("event: token\ndata: {\"te").isEmpty(), "chunk parziale: nessun evento");
    const QList<SseParser::Event> evs2 = p2.feed("xt\": \"ok\"}\n\n");
    CHECK(evs2.size() == 1, "evento completato dal secondo chunk");
    if (!evs2.isEmpty())
        CHECK(evs2.at(0).data.contains(QLatin1String("ok")), "payload ricomposto");
    // Evento con data su piu' righe.
    SseParser p3;
    const QList<SseParser::Event> evs3 = p3.feed("event: x\ndata: a\ndata: b\n\n");
    CHECK(evs3.size() == 1 && evs3.at(0).data == QLatin1String("a\nb"),
          "data multi-riga unito con newline");
 }
 static QString readFileTrim(const QString &path)
 {
    QFile f(path);
    if (!f.open(QIODevice::ReadOnly))
        return QString();
    return QString::fromUtf8(f.readAll()).trimmed();
 }
 int main(int argc, char **argv)
 {
    QCoreApplication app(argc, argv);
    app.setOrganizationName(QStringLiteral("harbour-test"));
    app.setApplicationName(QStringLiteral("hermes-test"));
    testParser();
    if (!app.arguments().contains(QStringLiteral("--live"))) {
        qDebug() << (failures == 0 ? "UNIT: tutti i test passati" : "UNIT: FALLIMENTI");
        return failures == 0 ? 0 : 1;
    }
    qDebug() << "== integrazione live (probe :8899) ==";
    QTimer::singleShot(180000, &app, []() {
        qWarning() << "TIMEOUT globale del test live";
        qApp->exit(2);
    });
    Settings settings;
    settings.setBaseUrl(QStringLiteral("http://127.0.0.1:8899"));
    ApiClient api(&settings);
    ChatModel chat(&api);
    const QString pw = readFileTrim(QStringLiteral("/tmp/hermes-probe/pw"));
    if (pw.isEmpty()) {
        qWarning() << "password del probe mancante in /tmp/hermes-probe/pw";
        return 1;
    }
    bool chatSent = false;
    bool chatDone = false;
    bool ttsDone = false;
    bool sttDone = false;
    QObject::connect(&api, &ApiClient::loggedInChanged, [&]() {
        if (api.loggedIn()) {
            qDebug() << "LIVE: login ok";
            chat.newSession();
        }
    });
    QObject::connect(&api, &ApiClient::sessionOpened, [&]() {
        if (chatSent)
            return;
        chatSent = true;
        qDebug() << "LIVE: sessione" << chat.sessionId();
        chat.send(QStringLiteral("Rispondi solo con la parola pong. Non usare strumenti."));
    });
    QObject::connect(&chat, &ChatModel::assistantFinished, [&]() {
        qDebug() << "LIVE: risposta =" << chat.lastAssistantText();
        chatDone = chat.lastAssistantText().contains(QLatin1String("pong"));
        api.speak(QStringLiteral("Questa e' la voce italiana del client Hermes per Sailfish."));
    });
    QObject::connect(&api, &ApiClient::ttsReady, [&](const QString &path) {
        QFile f(path);
        ttsDone = f.size() > 1000;
        qDebug() << "LIVE: ttsReady" << path << "bytes:" << f.size();
        api.transcribeFile(QStringLiteral("/tmp/hermes-probe/out/prova.ogg"));
    });
    QObject::connect(&api, &ApiClient::ttsFailed, [&](const QString &err) {
        qWarning() << "LIVE: ttsFailed" << err;
        api.transcribeFile(QStringLiteral("/tmp/hermes-probe/out/prova.ogg"));
    });
    QObject::connect(&api, &ApiClient::transcriptionReady, [&](const QString &text) {
        qDebug() << "LIVE: trascrizione =" << text;
        sttDone = !text.isEmpty();
        QTimer::singleShot(200, qApp, [&]() {
            const bool pass = chatDone && ttsDone && sttDone;
            qDebug() << (pass ? "LIVE: TUTTI I PASSAGGI OK" : "LIVE: qualche passaggio e' fallito");
            qApp->exit(pass ? 0 : 1);
        });
    });
    QObject::connect(&api, &ApiClient::transcriptionFailed, [&](const QString &err) {
        qWarning() << "LIVE: transcriptionFailed" << err;
        qApp->exit(1);
    });
    QObject::connect(&api, &ApiClient::chatStartFailed, [&](const QString &err) {
        qWarning() << "LIVE: chatStartFailed" << err;
        qApp->exit(1);
    });
    api.login(pw);
    qDebug() << "LIVE: login inviato";
    return app.exec();
 }
@@ -0,0 +1,33 @@
 TEMPLATE = app
 TARGET = core-test
 CONFIG += console c++11
 QT += core network multimedia
 # Workaround per la build locale su desktop senza libGL.so di sviluppo:
 # se esiste lo stub dir con il symlink a libGL.so.1, usalo.
 GLSTUB = /tmp/hh-test/gl
 exists($$GLSTUB/libGL.so) {
    LIBS += -L$$GLSTUB
 }
 SRC = $$PWD/../src
 INCLUDEPATH += $$SRC
 SOURCES += \
    $$SRC/sseparser.cpp \
    $$SRC/cookiejar.cpp \
    $$SRC/settings.cpp \
    $$SRC/apiclient.cpp \
    $$SRC/chatmodel.cpp \
    $$SRC/recorder.cpp \
    $$SRC/player.cpp \
    core_test.cpp
 HEADERS += \
    $$SRC/sseparser.h \
    $$SRC/cookiejar.h \
    $$SRC/settings.h \
    $$SRC/apiclient.h \
    $$SRC/chatmodel.h \
    $$SRC/recorder.h \
    $$SRC/player.h