Kreeader client

This repository contains the Tauri 2 desktop, mobile, and TV wrapper for Kreeader. The Svelte browser UI lives in the kreeader-ui git submodule. This repository owns the native Rust shell in src-tauri/, platform packaging, CI, and the combined build driver in build.sh.

The configured product name is Kreeader, the application identifier is in.jiggl.kreeader, and the main binary is kreeader-client.

Server connection

The UI communicates directly with a kreeader-server over HTTP. On first run, the application opens Settings so the server URL can be configured.

The server broadcasts the _kreeader._tcp mDNS service for clients that browse for it. This desktop application itself is configured by URL.

Development quickstart

Initialize the UI submodule and install the wrapper dependencies:

git submodule update --init
npm install

Build the UI and native application for the current machine:

./build.sh

For development, start the UI development server on port 1420 and run Tauri against a running kreeader-server:

npm --prefix kreeader-ui run dev
npm run tauri dev

The development server URL and port are configured in tauri.conf.json.

Building

The build driver accepts an optional target and subcommand:

./build.sh [--target <os>[-<arch>]] [subcommand]

Supported targets are:

• local is the default and builds for the current machine.
• linux builds the Linux application. Linux bundle targets are deb and rpm.
• macos-aarch64 and macos-x86_64 build on a Mac with the Xcode Command Line Tools installed.
• windows cross-compiles from Linux for x86_64-pc-windows-msvc using cargo-xwin and the NSIS makensis tool.
• android-aarch64 builds a debug APK and requires the Android NDK.
• ios requires a Mac and an Apple signing identity.

Build only the browser bundle at kreeader-ui/dist with:

./build.sh web

Always build the native application through npx tauri build, npm run tauri build, or build.sh. Do not use bare cargo build. The Tauri CLI enables the custom-protocol feature that embeds the built frontend; a bare Cargo build produces an application with no UI at runtime.

Rust shell

The native shell is in src-tauri/src/ and is thin by design. UI-to-server traffic uses plain HTTP. The opener plugin hands /debug deep links to the system browser.

• Phone remote: A small LAN web server listens on port 38400 (REMOTE_PORT in lib.rs). A single-use QR token authenticates a temporary WebSocket used for WebRTC signaling. Commands then travel over the encrypted peer-to-peer data channel and feed the same frontend handler used for server-relayed commands. The built kreeader-ui distribution is embedded into the binary at compile time with include_dir, so this LAN server can serve the SPA's /#/remote and /#/tv routes to a phone browser. Linux desktop builds advertise direct mode because WebKitGTK has no RTCPeerConnection; commands are relayed over the signaling WebSocket. All other platforms use the WebRTC DataChannel.
• Cast sender: cast.rs implements the desktop-only Google Cast sender with rust_cast. It discovers Chromecast targets by browsing _googlecast._tcp with mdns-sd. On Android and iOS, rust_cast cannot cross-compile because of openssl-sys, so cast_stub.rs supplies a same-shaped no-op API. Call sites and the Tauri command list remain identical across platforms.
• TV display plugin: tauri-plugin-tv-display/ is an in-repository Tauri v2 plugin, mobile-only and gated to Android and iOS in src-tauri/Cargo.toml. It gives phone and tablet builds a second "10-foot" screen. Its native Google Cast sender uses Kotlin or Swift with the Cast SDK, and its message-channel schema matches the desktop cast.rs sender. Native external-display support uses Android Presentation with WebView or an iOS second UIWindow with WKWebView, loading the UI's /#/tv route.
• DRM: drm.rs is the client-side unwrap and decrypt counterpart to kreeader-server's drm/drm.go wire format.
• Release integrity: fingerprint.rs and handshake.rs implement per-machine fingerprint hashing and a startup handshake with the server's POST /api/client/handshake. A 403 for release_revoked or fingerprint_banned hard-blocks the application with a native tauri-plugin-dialog dialog.
• Screenshot blocking: screenshot_block.rs contains per-platform enforcement.
• Token vault: tauri-plugin-stronghold provides encrypted-at-rest local storage for session and OIDC tokens through one implementation shared by desktop, Android, and iOS.

Continuous integration

Forgejo workflows are stored in .forgejo/workflows/:

• build-arch.yml builds Linux on every branch push and on desktop-v* tags using a self-hosted, containerized runner.
• build-windows.yml cross-compiles the Windows binary from Linux with cargo-xwin and NSIS; no native Windows machine is involved.
• build-macos.yml builds macOS aarch64 on a self-hosted macOS runner for pushes to master and desktop-v* tags.
• build-android.yml builds a debug APK on a self-hosted Android runner using a prebuilt SDK and NDK image.
• build-ios.yml runs the iOS build on the macOS runner for pushes to master. It is currently expected to fail at the sign/export stage because Apple signing secrets are not wired in; the workflow keeps that failure visible as its own row.
• check-ui-sync.yml fails when this repository's kreeader-ui submodule pointer differs from kreeader-server's. Both superprojects must track the same UI commit.
• release.yml creates a Forgejo release when a desktop-v* tag is pushed. The tag must match the version in package.json.
• version-build.yml computes SemVer {MAJOR}.{MINOR}.{REV} with scripts/compute-version.sh. MAJOR comes from lightweight major-N tags; MINOR and REV use commit-count arithmetic. It dispatches the Arch package build only when MINOR or MAJOR changes.

Testing

The Playwright end-to-end suite is configured by playwright.config.js and stored in e2e/. Run it with:

npm run test:e2e

Repository layout

• kreeader-ui/ — Svelte UI submodule; its dist/ is consumed by Tauri and can be embedded by the server.
• src-tauri/ — native Rust shell and Tauri configuration.
• tauri-plugin-tv-display/ — mobile Tauri plugin for Cast and external displays.
• build.sh — combined frontend and platform-aware native build driver.
• packaging/ — platform packaging files.
• scripts/ — repository build and version scripts.
• e2e/ — Playwright end-to-end tests.