No description
  • Rust 57.5%
  • TypeScript 23.2%
  • CSS 15.4%
  • Kotlin 1.6%
  • HTML 1%
  • Other 1.3%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
2026-10-15 19:10:00 +02:00
apk-dist change shit 2026-10-15 19:10:00 +02:00
scripts Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
src change shit 2026-10-15 19:10:00 +02:00
src-tauri change shit 2026-10-15 19:10:00 +02:00
.dockerignore Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
.gitignore Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
docker-compose.yml Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
Dockerfile.dev Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
index.html Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
LICENSE Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
package-lock.json Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
package.json Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
PLAN.md Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
README.md Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
tsconfig.json Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00
vite.config.ts Import Extrovert mobile client (Tauri) 2026-10-07 11:41:06 +02:00

Extrovert Mobile

A native Extrovert client for Android (now) and iOS / Linux (arm64 phones) / macOS (next), built with Tauri v2 + Rust and vodozemac for end-to-end encryption.

The UI reuses the website's own theme.css, fonts, icons and rings motif, so it looks like Extrovert — just re-flowed for a phone.

Licensed GPL-3.0-or-later, like Extrovert itself (this project reuses its design assets and links against its API).

Status

P0 (scaffold), P2 (E2EE + DMs), P3 (realtime + social), P4 (rooms + Megolm) and P5 (calls + Android) are complete and verified.

  • Calls: 1:1 audio over WebRTC, with signing relayed through the Rust gateway (the WebView never sees a token). Full state machine — call_request→callee_available, call_offer→incoming_call, call_answer, ICE relay, call_end/decline, busy/offline handling — plus presence, ICE config, and the native push channel for offline-call wake-ups including decline-by-token.

  • Android: the project is initialised, and tauri android build --debug --apk --target aarch64 produces an installable APK. A Kotlin foreground service keeps the push socket alive while backgrounded; Tauri already grants WebView mic permission (RECORD_AUDIO).

  • Rooms: create/join/leave, channels, roles, join requests, invites, kicks — plus Megolm group encryption: a per-device outbound session, keys wrapped for every member device over 1:1 Olm, the session/sync round trip (publish → pending → ack → share), and decryption of history and live messages. Room keys are shared only with members who lack a real key, using the missing_for_session bundle filter.

  • Realtime gateway (realtime.rs): connects with auto_subscribe=1, 30 s ping, reconnects with resume so no events are lost, and forwards every frame to the WebView as typed extrovert://gateway events. Auth rides in the handshake Authorization header, never the URL.

  • Social surface: feed with cursor pagination, create/edit/delete posts (text + photo/video), likes, reposts, comment threads, edit history, profiles with inline editing, follow/unfollow, search, friend-of-a-friend discovery, notifications, and the announcement banner.

  • Optimistic UI: posts and comments are sent with a client_id and reconciled against the gateway echo.

Earlier phases:

  • Tauri v2 + Vite/vanilla-TS app shell, bottom tab bar, safe-area handling;
  • the site's theme.css, variable fonts (trimmed to latin + latin-ext), icon set and rings SVG copied in;
  • extrovert-core: typed /api/v1 models, encrypted on-device store, REST client, and a full Olm (vodozemac) implementation — device registration, prekey publish/top-up, bundle claim, the web client's v:2 envelope, the self-session copy, and safety numbers;
  • auth: token sign-in and device pairing (pair/init → pair/claim, single-use), /client/bootstrap, sign-out, cold-start session restore;
  • encrypted DMs: conversation list, decrypting thread view (with local plaintext cache), compose, delete, safety number, and Additional-Security toggle/ack;
  • tests: unit + libolm golden vectors, cross-implementation interop (vodozemac ⇄ libolm, both directions), and live server tests.

Most importantly, the DM encryption is verified interoperable with the website: a native Rust client and the website's libolm engine decrypt each other's messages in both directions.

Still to do: rooms/Megolm (P4), calls/voice (P5), and the Android/iOS/desktop builds (P6). See PLAN.md.

Architecture

src/                 frontend (vanilla TS) — views only, no tokens, no keys
  main.ts router.ts state.ts api.ts dom.ts
  views/ components/ styles/ fonts/ vendor/
src-tauri/           Tauri shell (thin)
  src/lib.rs         #[tauri::command]s + state
  core/              extrovert-core — reusable, Tauri-free
    models.rs        serde types for every /api/v1 payload
    net.rs           REST client
    store.rs         AES-256-GCM on-device store
    olm.rs           vodozemac Olm + Megolm sessions and the v:2 envelope
    client.rs        device + HTTP orchestration (DMs and rooms)
    realtime.rs      WebSocket gateway client (auto-subscribe, resume, ping)
    e2ee.rs          safety numbers

Secrets (bearer tokens, and later Olm/Megolm pickles) live in extrovert-core; the WebView only calls typed commands. REST and the realtime gateway are handled in Rust so no bearer token ever reaches JavaScript.

Prerequisites

  • Rust (stable) and Node 20+
  • Tauri Linux build deps (only for a local desktop build; use Docker otherwise): libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libsoup-3.0-dev
  • For Android: the Android SDK/NDK + JDK 21, then npm run android:init

Develop

npm install
npm run dev            # Vite dev server (frontend only, in a browser)
npm run tauri dev      # full desktop app (needs the Linux deps above)

Point the app at a server on first launch (defaults to https://extrovert.redforged.eu) and sign in with a Personal Access Token or a pairing code.

Build

npm run build                 # typecheck + bundle the frontend
npm run tauri build           # desktop bundle
npm run android:build         # Android APK/AAB (needs the Android SDK)

Android setup (one-off)

The toolchain lives entirely in your home directory — no root needed:

# 1. Command-line tools (pick the latest build from developer.android.com/studio)
curl -Lo cmdline-tools.zip https://dl.google.com/android/repository/commandlinetools-linux-<BUILD>_latest.zip
mkdir -p ~/android-sdk/cmdline-tools && unzip -q cmdline-tools.zip -d ~/android-sdk/cmdline-tools
mv ~/android-sdk/cmdline-tools/cmdline-tools ~/android-sdk/cmdline-tools/latest

# 2. Packages + NDK
export ANDROID_HOME="$HOME/android-sdk"
export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
yes | sdkmanager --licenses
sdkmanager "platform-tools" "platforms;android-35" "build-tools;35.0.0" "ndk;29.0.14206865"

# 3. Rust targets
rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android

# 4. Generate the project and build (JDK 21 + NDK_HOME required)
export NDK_HOME="$HOME/android-sdk/ndk/29.0.14206865"
export JAVA_HOME=/usr/lib/jvm/temurin-21-jdk-amd64
npx tauri android init --ci
npx tauri android build --debug --apk --target aarch64
# → src-tauri/gen/android/app/build/outputs/apk/universal/debug/app-universal-debug.apk

The generated src-tauri/gen/android project is checked in deliberately — it carries the mic/notification permissions, the PushService foreground service and MainActivity changes that call wake-ups depend on.

Signed release build

Create a keystore once, then put its path and credentials in a gitignored src-tauri/gen/android/keystore.properties:

storeFile=release.keystore
storePassword=…
keyAlias=extrovert
keyPassword=…

app/build.gradle.kts reads that file into a release signing config (release builds are left unsigned when it is absent). Then:

npx tauri android build --apk --split-per-abi --target aarch64
# → app/build/outputs/apk/arm64/release/app-arm64-release.apk   (~20 MB)

Keep the keystore and its password. Losing them means you can never update the app under the same identity. Note the release build sets usesCleartextTraffic=false, so it only talks to https:// servers — use the debug build to test against a plain-http dev instance.

Test

Fast, hermetic:

npm run build                                    # tsc + vite
cargo test --manifest-path src-tauri/Cargo.toml -p extrovert-core --lib

# Cross-implementation E2EE interop (vodozemac <-> libolm, both directions):
sh scripts/interop-libolm.sh

Against a real, seeded server:

./scripts/dev-server.sh           # clones Extrovert into .dev/ and starts it
# or let the runner start the server and run everything (recommended):
sh scripts/run-live-tests.sh

scripts/run-live-tests.sh runs both the upstream client suites and the native ones (bootstrap/pairing, DMs, realtime gateway, social surface) against a seeded server, and fails loudly if the environment is half-configured.

The seeded fixtures are alice / bob / charlie (password123), room Town Square, and deterministic PATs.

Building without host toolchain

Dockerfile.dev has everything (Tauri deps + Rust + Node):

docker build -f Dockerfile.dev -t extrovert-mobile-dev .
docker run --rm -v "$PWD":/app -w /app/src-tauri extrovert-mobile-dev cargo check

Known upstream issue

src/webrtc-signaling.js:946 in the Extrovert server dereferences user.id on WebSocket close without checking that the socket authenticated first, so a connection to /ws that closes before authenticating can crash the process. It's a server-side robustness bug (fix: if (!user) return; in the close handler) and does not affect the client. Reported here for upstream.

License

GPL-3.0-or-later. See LICENSE.