From 213bc72b6489a6c88c3b95e7b3f4e80c71bea3df Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Mon, 24 Aug 2026 21:07:02 -0400 Subject: [PATCH] Phase 1 app: session list, session screen, spawn, QR enrollment over pinned TLS Compose app mirroring local-updater's stack (single :androidApp module, pinned CA, HttpURLConnection transport) plus what this app needs on top: a bearer token sealed with an Android Keystore AES-GCM key, an aiapp://enroll intent filter so scanning the server's terminal QR with the stock camera enrolls the phone with no QR library, an SSE client that resumes by transcript cursor, and a transcript renderer folding the common event model into user bubbles, streaming text, collapsible tool cards, and answerable question cards. Verified on the tdep emulator against the real server: enrollment deep link, list, spawn, streamed echo turn, question answer round trip, tool card expansion, adjustResize keyboard behavior. Build is warning-clean (compose.* accessors replaced with direct dependencies). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_017xn8nHw1tw1R6PtiY1eEtw --- .claude/settings.json | 8 + app/android-env.sh | 55 +++ app/androidApp/build.gradle.kts | 40 ++ app/androidApp/src/main/AndroidManifest.xml | 40 ++ .../src/main/kotlin/com/example/aiapp/Api.kt | 157 ++++++++ .../main/kotlin/com/example/aiapp/AppRoot.kt | 97 +++++ .../kotlin/com/example/aiapp/EventStream.kt | 80 ++++ .../main/kotlin/com/example/aiapp/Events.kt | 63 ++++ .../kotlin/com/example/aiapp/MainActivity.kt | 81 ++++ .../kotlin/com/example/aiapp/PinnedCert.kt | 68 ++++ .../kotlin/com/example/aiapp/ServerConfig.kt | 118 ++++++ .../com/example/aiapp/SessionListScreen.kt | 219 +++++++++++ .../kotlin/com/example/aiapp/SessionScreen.kt | 349 ++++++++++++++++++ .../com/example/aiapp/SettingsScreen.kt | 110 ++++++ .../kotlin/com/example/aiapp/SpawnScreen.kt | 105 ++++++ app/build.gradle.kts | 5 + app/gradle.properties | 7 + app/gradle/libs.versions.toml | 23 ++ app/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 47505 bytes app/gradle/wrapper/gradle-wrapper.properties | 7 + app/gradlew | 248 +++++++++++++ app/gradlew.bat | 82 ++++ app/run-android.sh | 106 ++++++ app/settings.gradle.kts | 18 + 24 files changed, 2086 insertions(+) create mode 100644 .claude/settings.json create mode 100755 app/android-env.sh create mode 100644 app/androidApp/build.gradle.kts create mode 100644 app/androidApp/src/main/AndroidManifest.xml create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/Api.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/AppRoot.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/EventStream.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/Events.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/MainActivity.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/PinnedCert.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/ServerConfig.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/SessionListScreen.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/SessionScreen.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/SettingsScreen.kt create mode 100644 app/androidApp/src/main/kotlin/com/example/aiapp/SpawnScreen.kt create mode 100644 app/build.gradle.kts create mode 100644 app/gradle.properties create mode 100644 app/gradle/libs.versions.toml create mode 100644 app/gradle/wrapper/gradle-wrapper.jar create mode 100644 app/gradle/wrapper/gradle-wrapper.properties create mode 100755 app/gradlew create mode 100644 app/gradlew.bat create mode 100755 app/run-android.sh create mode 100644 app/settings.gradle.kts diff --git a/.claude/settings.json b/.claude/settings.json new file mode 100644 index 0000000..d0f0a29 --- /dev/null +++ b/.claude/settings.json @@ -0,0 +1,8 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "env": { + "ANDROID_HOME": "/home/bob/Android/Sdk", + "ANDROID_SDK_ROOT": "/home/bob/Android/Sdk", + "PATH": "/home/bob/Android/Sdk/platform-tools:/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl:/usr/lib/rustup/bin:/home/bob/.local/bin" + } +} diff --git a/app/android-env.sh b/app/android-env.sh new file mode 100755 index 0000000..e11b2be --- /dev/null +++ b/app/android-env.sh @@ -0,0 +1,55 @@ +#!/bin/sh +# Android SDK environment for this app's Gradle build: locates the SDK and +# exports the PATH/env vars the build needs. Pure Kotlin/Gradle, so nothing +# Rust/NDK-specific belongs here. +# +# Source this directly for one-off commands instead of going through the +# full run-android.sh (which also creates/boots the emulator, builds, +# installs, and launches): +# +# . ./android-env.sh +# ./gradlew :androidApp:assembleDebug +# adb devices +# +# Safe to source repeatedly. Intentionally does NOT `set -e`/`set -u`: this +# file is meant to be sourced into whatever shell is already running -- +# including a long-lived one a session reuses for unrelated commands -- and +# changing that shell's error-handling options as a side effect of sourcing +# would be surprising. run-android.sh, which does want strict mode, sets its +# own `set -eu` before sourcing this. + +# Hardcoded (not derived from an inherited ANDROID_HOME) so this doesn't +# silently follow whatever that happens to be set to elsewhere -- e.g. this +# sandbox's own profile exports ANDROID_HOME=/opt/android-sdk system-wide, a +# root-owned install this user can't write to. Everything needed lives under +# the path below instead, matching Android Studio's own default SDK location +# convention on Linux. +SDK_ROOT="$HOME/Android/Sdk" +ANDROID_HOME="$SDK_ROOT" +ANDROID_SDK_ROOT="$SDK_ROOT" +# ~/.local/bin is where the `android` CLI itself installs to (see its own +# installer); adding it here too means sourcing this script guarantees a +# working `android` command even in a shell that hasn't picked up +# ~/.profile yet. +PATH="$HOME/.local/bin:$SDK_ROOT/cmdline-tools/latest/bin:$SDK_ROOT/platform-tools:$SDK_ROOT/emulator:$PATH" +# Pin the AVD directory explicitly so avdmanager (creation) and the emulator +# binary (lookup at start time) are guaranteed to agree on where the AVD +# lives -- left to their own defaults they can resolve different locations +# and disagree on whether it exists. +ANDROID_AVD_HOME="${ANDROID_AVD_HOME:-$HOME/.android/avd}" +mkdir -p "$ANDROID_AVD_HOME" +export ANDROID_HOME ANDROID_SDK_ROOT ANDROID_AVD_HOME PATH + +echo "==> Ensuring required SDK packages are installed in $SDK_ROOT" +# $SDK_ROOT is user-owned (unlike /opt/android-sdk), so this genuinely +# installs anything missing rather than just probing for it -- still +# best-effort (`|| echo`) so a transient network hiccup doesn't abort a +# script sourcing this under `set -e`. +# +# build-tools is needed twice over: by Gradle for this app's own build, and +# by ../server at runtime for `aapt2` (reading a discovered APK's package +# name) and `llvm-strip`/`apksigner` (the slim-APK pipeline). +android sdk install "cmdline-tools/latest" "platform-tools" "emulator" \ + "platforms/android-37.0" "build-tools/37.0.0" \ + "system-images/android-36/google_apis/x86_64" \ + || echo " (non-fatal: see above)" diff --git a/app/androidApp/build.gradle.kts b/app/androidApp/build.gradle.kts new file mode 100644 index 0000000..35a5a9d --- /dev/null +++ b/app/androidApp/build.gradle.kts @@ -0,0 +1,40 @@ +plugins { + alias(libs.plugins.androidApplication) + alias(libs.plugins.composeMultiplatform) + alias(libs.plugins.composeCompiler) +} + +android { + namespace = "com.example.aiapp" + compileSdk = 37 + + defaultConfig { + applicationId = "com.example.aiapp" + minSdk = 24 + targetSdk = 37 + versionCode = 1 + versionName = "1.0" + } + packaging { + resources { + excludes += "/META-INF/{AL2.0,LGPL2.1}" + } + } + buildTypes { + getByName("release") { + isMinifyEnabled = false + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 + } +} + +dependencies { + implementation(libs.compose.runtime) + implementation(libs.compose.foundation) + implementation(libs.compose.material3) + implementation(libs.compose.ui) + implementation(libs.androidx.activity.compose) +} diff --git a/app/androidApp/src/main/AndroidManifest.xml b/app/androidApp/src/main/AndroidManifest.xml new file mode 100644 index 0000000..c2e43e1 --- /dev/null +++ b/app/androidApp/src/main/AndroidManifest.xml @@ -0,0 +1,40 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/Api.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/Api.kt new file mode 100644 index 0000000..dba837d --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/Api.kt @@ -0,0 +1,157 @@ +package com.example.aiapp + +import org.json.JSONArray +import org.json.JSONObject +import java.io.IOException +import java.net.HttpURLConnection +import java.net.URL + +// The REST half of the backend's surface (see server/src/routes.rs for the +// table); the SSE half is EventStream.kt. All blocking network calls -- +// invoke from a background dispatcher. Each throws ApiException on failure, +// carrying the server's own explanation where it sent one, since those +// messages are written to be read on this screen. + +private const val CONNECT_TIMEOUT_MS = 5000 + +class ApiException(message: String, cause: Throwable? = null) : Exception(message, cause) + +/** + * Runs one request against the backend, with the pinned TLS setup, the + * bearer token, and the failure translation every call needs. [readBody] + * gets the connected, already-status-checked connection to read from. + * + * @param readTimeoutMs how long to wait on the response body. The SSE + * stream doesn't come through here -- an event stream has no bounded + * read time (see EventStream.kt). + */ +fun requestFromServer( + settings: ServerSettings, + path: String, + method: String = "GET", + jsonBody: String? = null, + readTimeoutMs: Int = 5000, + readBody: (HttpURLConnection) -> T, +): T { + val connection = URL("${settings.baseUrl}$path").openConnection() as HttpURLConnection + try { + connection.applyPinnedTls() + connection.requestMethod = method + connection.connectTimeout = CONNECT_TIMEOUT_MS + connection.readTimeout = readTimeoutMs + connection.setRequestProperty("Authorization", "Bearer ${settings.token}") + if (jsonBody != null) { + connection.doOutput = true + connection.setRequestProperty("Content-Type", "application/json") + connection.outputStream.use { it.write(jsonBody.encodeToByteArray()) } + } + if (connection.responseCode !in 200..299) { + val detail = connection.errorStream?.bufferedReader()?.readText()?.trim() + throw ApiException( + when { + connection.responseCode == 401 -> + "The server rejected this device's token. Re-enroll by scanning " + + "the server's QR (or rotate with --rotate-token and scan the new one)." + detail.isNullOrEmpty() -> + "Server returned HTTP ${connection.responseCode} for $path" + else -> detail + }, + ) + } + return readBody(connection) + } catch (e: ApiException) { + throw e + } catch (e: IOException) { + // Surfacing the real exception (rather than one canned message for + // every failure mode) is what lets this be diagnosed on a device + // with no logcat access. + throw ApiException( + "Couldn't reach the server at ${settings.baseUrl} " + + "(${e::class.simpleName}: ${e.message}) -- is ai-server running, and is " + + "this device able to reach that address (WireGuard up)?", + e, + ) + } catch (e: Exception) { + throw ApiException( + "Reached ${settings.baseUrl}$path but couldn't read its response " + + "(${e::class.simpleName}: ${e.message})", + e, + ) + } finally { + connection.disconnect() + } +} + +// One row of GET /sessions. +data class SessionSummary( + val id: String, + val kind: String, + val title: String, + val host: String?, + val model: String?, + val status: String, + val lastActivity: Double, +) + +fun fetchSessions(settings: ServerSettings): List = + requestFromServer(settings, "/sessions") { connection -> + val sessions = JSONArray(connection.inputStream.bufferedReader().readText()) + (0 until sessions.length()).map { i -> + val session = sessions.getJSONObject(i) + SessionSummary( + id = session.getString("id"), + kind = session.getString("kind"), + title = session.getString("title"), + host = session.optString("host").ifEmpty { null }, + model = session.optString("model").ifEmpty { null }, + status = session.getString("status"), + lastActivity = session.getDouble("lastActivity"), + ) + } + } + +/** Spawns a session and returns it as the list would show it. */ +fun spawnSession(settings: ServerSettings, kind: String, title: String): SessionSummary = + requestFromServer( + settings, + "/sessions", + method = "POST", + jsonBody = JSONObject().put("kind", kind).put("title", title).toString(), + ) { connection -> + val session = JSONObject(connection.inputStream.bufferedReader().readText()) + SessionSummary( + id = session.getString("id"), + kind = session.getString("kind"), + title = session.getString("title"), + host = session.optString("host").ifEmpty { null }, + model = session.optString("model").ifEmpty { null }, + status = session.getString("status"), + lastActivity = session.getDouble("lastActivity"), + ) + } + +fun sendMessage(settings: ServerSettings, sessionId: String, text: String) { + requestFromServer( + settings, + "/sessions/$sessionId/message", + method = "POST", + jsonBody = JSONObject().put("text", text).toString(), + ) {} +} + +fun answerQuestion(settings: ServerSettings, sessionId: String, questionId: String, answer: String) { + requestFromServer( + settings, + "/sessions/$sessionId/answer", + method = "POST", + jsonBody = JSONObject().put("questionId", questionId).put("answer", answer).toString(), + ) {} +} + +fun interruptSession(settings: ServerSettings, sessionId: String) { + requestFromServer(settings, "/sessions/$sessionId/interrupt", method = "POST") {} +} + +fun deleteSession(settings: ServerSettings, sessionId: String) { + requestFromServer(settings, "/sessions/$sessionId", method = "DELETE") {} +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/AppRoot.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/AppRoot.kt new file mode 100644 index 0000000..f5c5f6b --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/AppRoot.kt @@ -0,0 +1,97 @@ +package com.example.aiapp + +import androidx.activity.compose.BackHandler +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.platform.LocalContext + +/** + * One `when` rather than a navigation library: four screens, with the list + * as the root and the back button the only other way between them. + */ +private sealed class Screen { + data object SessionList : Screen() + data class Session(val summary: SessionSummary) : Screen() + data object Spawn : Screen() + data object Settings : Screen() +} + +/** + * [settingsVersion] bumps when enrollment lands via an `aiapp://` intent + * (see MainActivity), re-reading the stored settings -- a plain `remember` + * would keep serving the pre-enrollment null. + */ +@Composable +fun AppRoot(settingsVersion: Int) { + val context = LocalContext.current + var settings by remember(settingsVersion) { mutableStateOf(loadServerSettings(context)) } + var screen by remember { mutableStateOf(Screen.SessionList) } + // Bumped whenever another screen changes something the list shows, so + // returning to it refetches instead of showing a stale list. + var reloadToken by remember { mutableStateOf(0) } + + val current = settings + if (current == null) { + // Not enrolled yet: settings is the only usable screen. The QR + // path lands in MainActivity and recomposes from the top. + SettingsScreen( + existing = null, + onSaved = { saved -> + settings = saved + screen = Screen.SessionList + }, + onBack = null, + ) + return + } + + when (val here = screen) { + is Screen.SessionList -> SessionListScreen( + settings = current, + reloadToken = reloadToken, + onOpen = { screen = Screen.Session(it) }, + onSpawn = { screen = Screen.Spawn }, + onSettings = { screen = Screen.Settings }, + ) + is Screen.Session -> { + BackHandler { + reloadToken++ + screen = Screen.SessionList + } + SessionScreen( + settings = current, + summary = here.summary, + onBack = { + reloadToken++ + screen = Screen.SessionList + }, + ) + } + is Screen.Spawn -> { + BackHandler { screen = Screen.SessionList } + SpawnScreen( + settings = current, + onSpawned = { spawned -> + reloadToken++ + screen = Screen.Session(spawned) + }, + onBack = { screen = Screen.SessionList }, + ) + } + is Screen.Settings -> { + BackHandler { screen = Screen.SessionList } + SettingsScreen( + existing = current, + onSaved = { saved -> + settings = saved + reloadToken++ + screen = Screen.SessionList + }, + onBack = { screen = Screen.SessionList }, + ) + } + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/EventStream.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/EventStream.kt new file mode 100644 index 0000000..e4c7083 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/EventStream.kt @@ -0,0 +1,80 @@ +package com.example.aiapp + +import java.io.IOException +import java.net.HttpURLConnection +import java.net.URL + +/** + * The SSE half of the API: one long-lived GET per open session screen, + * replaying the transcript after a cursor and then following it live. + * + * Blocking -- run() occupies its thread until the stream ends. [close] + * (from any thread) is the cancellation path: it disconnects the socket, + * which unblocks the read; run() then returns instead of throwing, so a + * deliberate close doesn't surface as a connection error. The caller owns + * reconnecting (with the last seq it saw as the new cursor) -- see + * SessionScreen. + */ +class EventStream(private val settings: ServerSettings, private val sessionId: String) { + @Volatile private var connection: HttpURLConnection? = null + @Volatile private var closed = false + + fun close() { + closed = true + connection?.disconnect() + } + + /** Streams events after [after] into [onEvent] until the stream drops. */ + fun run(after: Long, onEvent: (SeqEvent) -> Unit) { + val connection = + URL("${settings.baseUrl}/sessions/$sessionId/events?after=$after").openConnection() + as HttpURLConnection + this.connection = connection + try { + connection.applyPinnedTls() + connection.connectTimeout = 5000 + // No read timeout: between events there is nothing to read for + // as long as the session is idle; the server's keep-alives and + // a dead socket erroring out are the liveness story. + connection.readTimeout = 0 + connection.setRequestProperty("Authorization", "Bearer ${settings.token}") + connection.setRequestProperty("Accept", "text/event-stream") + if (connection.responseCode != 200) { + val detail = connection.errorStream?.bufferedReader()?.readText()?.trim() + throw ApiException(detail ?: "HTTP ${connection.responseCode} for the event stream") + } + + val reader = connection.inputStream.bufferedReader() + // SSE framing: `data:` lines accumulate until a blank line ends + // the event. `id:` (the seq) is also inside the JSON payload, + // so only data lines matter; comment lines (keep-alives) start + // with ':' and are skipped. + val data = StringBuilder() + while (true) { + val line = reader.readLine() ?: break + when { + line.isEmpty() -> { + if (data.isNotEmpty()) { + onEvent(parseSeqEvent(data.toString())) + data.clear() + } + } + line.startsWith("data:") -> data.append(line.removePrefix("data:").trim()) + else -> {} // id:, event:, comments -- nothing to do + } + } + } catch (e: ApiException) { + throw e + } catch (e: IOException) { + if (!closed) { + throw ApiException( + "Lost the event stream (${e::class.simpleName}: ${e.message})", + e, + ) + } + } finally { + connection.disconnect() + this.connection = null + } + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/Events.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/Events.kt new file mode 100644 index 0000000..73e47a7 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/Events.kt @@ -0,0 +1,63 @@ +package com.example.aiapp + +import org.json.JSONObject + +// The common event model, mirrored from server/src/session/driver.rs -- +// the app renders purely from this stream (replayed from the transcript by +// cursor, then live), so there is no separate "load history" shape to keep +// in sync with it. + +/** One transcript line: the event plus its resume cursor and time. */ +data class SeqEvent(val seq: Long, val ts: Double, val event: SessionEvent) + +sealed class SessionEvent { + data class UserMessage(val text: String) : SessionEvent() + data class AssistantText(val delta: String) : SessionEvent() + data class ToolStart(val id: String, val tool: String, val input: String) : SessionEvent() + data class ToolUpdate(val id: String, val output: String) : SessionEvent() + data class ToolEnd(val id: String, val output: String) : SessionEvent() + data class Image(val ref: String) : SessionEvent() + data class Question(val id: String, val prompt: String, val options: List) : SessionEvent() + data class Answered(val id: String, val answer: String) : SessionEvent() + data class Status(val state: String) : SessionEvent() + data class UsageDelta(val tokens: Long) : SessionEvent() + data class Error(val message: String) : SessionEvent() + + /** + * An event type this app build doesn't know -- a newer server. Kept + * (not thrown) so one new event kind degrades to a placeholder row + * instead of killing the stream. + */ + data class Unknown(val type: String) : SessionEvent() +} + +fun parseSeqEvent(json: String): SeqEvent { + val body = JSONObject(json) + val event = when (val type = body.getString("type")) { + "userMessage" -> SessionEvent.UserMessage(body.getString("text")) + "assistantText" -> SessionEvent.AssistantText(body.getString("delta")) + "toolStart" -> SessionEvent.ToolStart( + id = body.getString("id"), + tool = body.getString("tool"), + // Kept as raw JSON text: the input shape is the tool's own + // business, and the UI only ever shows it verbatim. + input = body.get("input").toString(), + ) + "toolUpdate" -> SessionEvent.ToolUpdate(body.getString("id"), body.getString("output")) + "toolEnd" -> SessionEvent.ToolEnd(body.getString("id"), body.getString("output")) + "image" -> SessionEvent.Image(body.getString("ref")) + "question" -> SessionEvent.Question( + id = body.getString("id"), + prompt = body.getString("prompt"), + options = body.getJSONArray("options").let { options -> + (0 until options.length()).map { options.getString(it) } + }, + ) + "answered" -> SessionEvent.Answered(body.getString("id"), body.getString("answer")) + "status" -> SessionEvent.Status(body.getString("state")) + "usageDelta" -> SessionEvent.UsageDelta(body.getLong("tokens")) + "error" -> SessionEvent.Error(body.getString("message")) + else -> SessionEvent.Unknown(type) + } + return SeqEvent(seq = body.getLong("seq"), ts = body.getDouble("ts"), event = event) +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/MainActivity.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/MainActivity.kt new file mode 100644 index 0000000..0cd2e5c --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/MainActivity.kt @@ -0,0 +1,81 @@ +package com.example.aiapp + +import android.Manifest +import android.content.Intent +import android.os.Build +import android.os.Bundle +import android.widget.Toast +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.core.view.WindowCompat + +class MainActivity : ComponentActivity() { + // Bumped whenever enrollment lands via an aiapp:// intent so the + // composition below re-reads the stored settings. + private var settingsVersion by mutableStateOf(0) + + // Registered up front since permission launchers must be registered + // before the activity reaches STARTED. + private val requestLocalNetworkPermission = + registerForActivityResult(ActivityResultContracts.RequestPermission()) {} + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + // Transparent status bar on every version; the Surface below paints + // through underneath it and content insets itself. Same reasoning + // as local-updater's MainActivity. + enableEdgeToEdge() + WindowCompat.getInsetsController(window, window.decorView).isAppearanceLightStatusBars = true + + // Android 17+ silently drops local-network traffic without this; + // requested up front because a denial is invisible at the socket + // layer (it just times out). + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CINNAMON_BUN) { + requestLocalNetworkPermission.launch(Manifest.permission.ACCESS_LOCAL_NETWORK) + } + + handleEnrollment(intent) + + setContent { + MaterialTheme { + Surface(modifier = Modifier.fillMaxSize()) { + Box(modifier = Modifier.fillMaxSize().statusBarsPadding().imePadding()) { + AppRoot(settingsVersion) + } + } + } + } + } + + // launchMode="singleTop": an enrollment scan while the app is open + // lands here rather than in a second activity instance. + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + handleEnrollment(intent) + } + + private fun handleEnrollment(intent: Intent?) { + val uri = intent?.data ?: return + val settings = parseEnrollmentUri(uri) + if (settings == null) { + Toast.makeText(this, "Not a valid enrollment code", Toast.LENGTH_LONG).show() + return + } + saveServerSettings(this, settings) + settingsVersion++ + Toast.makeText(this, "Enrolled with ${settings.baseUrl}", Toast.LENGTH_LONG).show() + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/PinnedCert.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/PinnedCert.kt new file mode 100644 index 0000000..9407cc4 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/PinnedCert.kt @@ -0,0 +1,68 @@ +package com.example.aiapp + +import java.io.ByteArrayInputStream +import java.net.HttpURLConnection +import java.security.KeyStore +import java.security.cert.CertificateFactory +import javax.net.ssl.HttpsURLConnection +import javax.net.ssl.SSLContext +import javax.net.ssl.SSLSocketFactory +import javax.net.ssl.TrustManagerFactory +import javax.net.ssl.X509TrustManager + +/** + * PEM-encoded dev CA certificate this repo's `gen-dev-cert.sh` generates -- + * the sole trust anchor for every request this app makes. The server's TLS + * listener presents a leaf certificate signed by this CA. Everything behind + * that listener *is* remote code execution on the backend, so this app + * trusts exactly this CA and nothing else -- not even the system store. + * + * Regenerating that CA means updating this to match; its SHA-256 + * fingerprint is printed by the script and saved to `certs/ca-sha256.txt`. + * The QR enrollment deliberately does not carry the CA: trust lives here in + * the APK, so photographing the terminal leaks only the (rotatable) token. + */ +const val PINNED_CA_PEM = """-----BEGIN CERTIFICATE----- +MIIBrjCCAVWgAwIBAgIUGomDFgIrkwxX9504lixc8kM83I0wCgYIKoZIzj0EAwIw +LTETMBEGA1UECgwKYWktYXBwIGRldjEWMBQGA1UEAwwNYWktYXBwIGRldiBDQTAe +Fw0yNjA4MjUwMDQ5NDBaFw0zNjA4MjIwMDQ5NDBaMC0xEzARBgNVBAoMCmFpLWFw +cCBkZXYxFjAUBgNVBAMMDWFpLWFwcCBkZXYgQ0EwWTATBgcqhkjOPQIBBggqhkjO +PQMBBwNCAARW8deDZhiVxUDo1TyGMIpOpvu45vei8Vd5rWFNgSOl80h8TQ8/v8fI +tcacAGiPK0OUDOPb6iSaSMS8QEtfPB8+o1MwUTAdBgNVHQ4EFgQUFnEtKeV8et8Z +O7/ihnMOckS45qwwHwYDVR0jBBgwFoAUFnEtKeV8et8ZO7/ihnMOckS45qwwDwYD +VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAgNHADBEAiBppx+X09AjEJ8X24KxHYaX +4NRE+8OlxqJCrkuAM7tLagIgND6JvA5K0WjlfZxomla45C5Vd91j2jdIPmM+UkEa +Wb4= +-----END CERTIFICATE----- +""" + +/** + * Trusts only [PINNED_CA_PEM], not the device's system trust store, so a + * real CA-issued cert for some other host wouldn't be accepted either. + * Built once and cached -- every SSE reconnect would otherwise redo the + * KeyStore/TrustManager setup from scratch. + */ +val pinnedSslSocketFactory: SSLSocketFactory by lazy { + val caCert = CertificateFactory.getInstance("X.509") + .generateCertificate(ByteArrayInputStream(PINNED_CA_PEM.encodeToByteArray())) + val keyStore = KeyStore.getInstance(KeyStore.getDefaultType()).apply { + load(null, null) + setCertificateEntry("ai-app-dev-ca", caCert) + } + val trustManager = TrustManagerFactory + .getInstance(TrustManagerFactory.getDefaultAlgorithm()) + .apply { init(keyStore) } + .trustManagers + .filterIsInstance() + .first() + SSLContext.getInstance("TLS").apply { + init(null, arrayOf(trustManager), null) + }.socketFactory +} + +/** Every request this app makes goes through this -- there is no unpinned path. */ +fun HttpURLConnection.applyPinnedTls() { + if (this is HttpsURLConnection) { + sslSocketFactory = pinnedSslSocketFactory + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/ServerConfig.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/ServerConfig.kt new file mode 100644 index 0000000..a012f41 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/ServerConfig.kt @@ -0,0 +1,118 @@ +package com.example.aiapp + +import android.content.Context +import android.net.Uri +import android.security.keystore.KeyGenParameterSpec +import android.security.keystore.KeyProperties +import android.util.Base64 +import java.security.KeyStore +import javax.crypto.Cipher +import javax.crypto.KeyGenerator +import javax.crypto.SecretKey +import javax.crypto.spec.GCMParameterSpec + +/** + * Where the backend is and how to authenticate to it. Absent until the + * phone is enrolled -- by scanning the server's terminal QR (an + * `aiapp://enroll` URI the camera app hands to MainActivity) or by typing + * the fields into the settings screen. + */ +data class ServerSettings(val host: String, val port: Int, val token: String) { + val baseUrl: String get() = "https://$host:$port" +} + +private const val PREFS_NAME = "server" +private const val KEY_HOST = "host" +private const val KEY_PORT = "port" +private const val KEY_TOKEN = "token" + +fun loadServerSettings(context: Context): ServerSettings? { + val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) + val host = prefs.getString(KEY_HOST, null) ?: return null + val port = prefs.getInt(KEY_PORT, 0) + val sealed = prefs.getString(KEY_TOKEN, null) ?: return null + val token = unseal(sealed) ?: return null + if (port == 0 || token.isEmpty()) return null + return ServerSettings(host, port, token) +} + +fun saveServerSettings(context: Context, settings: ServerSettings) { + context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE) + .edit() + .putString(KEY_HOST, settings.host) + .putInt(KEY_PORT, settings.port) + .putString(KEY_TOKEN, seal(settings.token)) + .apply() +} + +/** + * Parses the enrollment URI the server's QR carries: + * `aiapp://enroll?host=10.66.0.1&port=8443&token=...`. Null if any part is + * missing -- a malformed scan shouldn't clobber a working enrollment. + */ +fun parseEnrollmentUri(uri: Uri): ServerSettings? { + if (uri.scheme != "aiapp" || uri.host != "enroll") return null + val host = uri.getQueryParameter("host") ?: return null + val port = uri.getQueryParameter("port")?.toIntOrNull() ?: return null + val token = uri.getQueryParameter("token") ?: return null + if (host.isEmpty() || token.isEmpty()) return null + return ServerSettings(host, port, token) +} + +// --------------------------------------------------------------------------- +// Token sealing. The token is the credential for remote code execution on +// the backend, so it is stored AES-GCM-encrypted under an Android Keystore +// key (hardware-backed where the device has it) rather than in plain +// preferences. Hand-rolled (~40 lines) instead of Jetpack's +// EncryptedSharedPreferences because that library is deprecated with no +// drop-in successor -- Google's own guidance is now "use Keystore directly". + +private const val KEYSTORE = "AndroidKeyStore" +private const val KEY_ALIAS = "aiapp-token-key" +private const val GCM_TAG_BITS = 128 + +private fun tokenKey(): SecretKey { + val keyStore = KeyStore.getInstance(KEYSTORE).apply { load(null) } + (keyStore.getKey(KEY_ALIAS, null) as? SecretKey)?.let { return it } + val generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, KEYSTORE) + generator.init( + KeyGenParameterSpec.Builder( + KEY_ALIAS, + KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT, + ) + .setBlockModes(KeyProperties.BLOCK_MODE_GCM) + .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE) + .build(), + ) + return generator.generateKey() +} + +/** iv:ciphertext, both base64 -- the stored form of the token. */ +private fun seal(token: String): String { + val cipher = Cipher.getInstance("AES/GCM/NoPadding") + cipher.init(Cipher.ENCRYPT_MODE, tokenKey()) + val ciphertext = cipher.doFinal(token.encodeToByteArray()) + return Base64.encodeToString(cipher.iv, Base64.NO_WRAP) + ":" + + Base64.encodeToString(ciphertext, Base64.NO_WRAP) +} + +/** + * Null on any failure -- e.g. the Keystore key was lost to a device reset + * or the app's data was restored onto another device, where the key never + * travels. The caller treats that as "not enrolled"; re-scanning the QR + * (or `--rotate-token`) is the recovery, so failing soft here is right. + */ +private fun unseal(sealed: String): String? = try { + val (ivB64, dataB64) = sealed.split(":", limit = 2).let { + if (it.size != 2) return null else it[0] to it[1] + } + val cipher = Cipher.getInstance("AES/GCM/NoPadding") + cipher.init( + Cipher.DECRYPT_MODE, + tokenKey(), + GCMParameterSpec(GCM_TAG_BITS, Base64.decode(ivB64, Base64.NO_WRAP)), + ) + cipher.doFinal(Base64.decode(dataB64, Base64.NO_WRAP)).decodeToString() +} catch (_: Exception) { + null +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/SessionListScreen.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/SessionListScreen.kt new file mode 100644 index 0000000..1951759 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/SessionListScreen.kt @@ -0,0 +1,219 @@ +package com.example.aiapp + +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.combinedClickable +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Card +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.FloatingActionButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +// Status colors, keyed by the wire strings in Events.kt. Light theme only, +// as in local-updater. +private val AWAITING_COLOR = Color(0xFFB26A00) +private val RUNNING_COLOR = Color(0xFF2E7D32) + +private sealed class ListState { + data object Loading : ListState() + data class Loaded(val sessions: List) : ListState() + data class Error(val message: String) : ListState() +} + +/** + * The session list -- the app's root screen. Sessions awaiting an answer + * sort to the top: that's the "your turn" inbox. + */ +@Composable +fun SessionListScreen( + settings: ServerSettings, + reloadToken: Int, + onOpen: (SessionSummary) -> Unit, + onSpawn: () -> Unit, + onSettings: () -> Unit, +) { + val scope = rememberCoroutineScope() + var listState by remember { mutableStateOf(ListState.Loading) } + var confirmingDelete by remember { mutableStateOf(null) } + + fun refresh() { + listState = ListState.Loading + scope.launch { + listState = try { + withContext(Dispatchers.IO) { ListState.Loaded(fetchSessions(settings)) } + } catch (e: ApiException) { + ListState.Error(e.message ?: "Unknown error") + } + } + } + + LaunchedEffect(reloadToken) { refresh() } + + Box(Modifier.fillMaxSize()) { + Column(Modifier.fillMaxSize().padding(16.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text( + "AI Sessions", + style = MaterialTheme.typography.headlineSmall, + modifier = Modifier.weight(1f), + ) + TextButton(onClick = onSettings) { Text("Settings") } + TextButton(onClick = { refresh() }) { Text("Refresh") } + } + Spacer(Modifier.height(16.dp)) + + when (val state = listState) { + is ListState.Loading -> CircularProgressIndicator() + is ListState.Error -> Text( + "Couldn't reach the server: ${state.message}", + color = MaterialTheme.colorScheme.error, + ) + is ListState.Loaded -> { + if (state.sessions.isEmpty()) { + Text( + "No sessions. Tap + to spawn one.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + // Awaiting-answer first (the point of the screen), then + // most recently active. + val ordered = state.sessions.sortedWith( + compareByDescending { it.status == "awaitingInput" } + .thenByDescending { it.lastActivity }, + ) + LazyColumn { + items(ordered, key = { it.id }) { session -> + SessionCard( + session = session, + onOpen = { onOpen(session) }, + onLongPress = { confirmingDelete = session }, + ) + Spacer(Modifier.height(12.dp)) + } + } + } + } + } + + FloatingActionButton( + onClick = onSpawn, + modifier = Modifier.align(Alignment.BottomEnd).padding(24.dp), + ) { Text("+", style = MaterialTheme.typography.headlineMedium) } + } + + confirmingDelete?.let { session -> + AlertDialog( + onDismissRequest = { confirmingDelete = null }, + title = { Text("Delete \"${session.title}\"?") }, + text = { Text("Kills the process and deletes its transcript. This can't be undone.") }, + confirmButton = { + TextButton(onClick = { + confirmingDelete = null + scope.launch { + try { + withContext(Dispatchers.IO) { deleteSession(settings, session.id) } + refresh() + } catch (e: ApiException) { + listState = ListState.Error(e.message ?: "Delete failed") + } + } + }) { Text("Delete") } + }, + dismissButton = { + TextButton(onClick = { confirmingDelete = null }) { Text("Cancel") } + }, + ) + } +} + +@OptIn(ExperimentalFoundationApi::class) +@Composable +private fun SessionCard( + session: SessionSummary, + onOpen: () -> Unit, + onLongPress: () -> Unit, +) { + Card( + Modifier.fillMaxWidth().combinedClickable(onClick = onOpen, onLongClick = onLongPress), + ) { + Column(Modifier.padding(16.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text( + session.title, + style = MaterialTheme.typography.titleMedium, + modifier = Modifier.weight(1f), + ) + StatusText(session.status) + } + Spacer(Modifier.height(4.dp)) + Row(modifier = Modifier.fillMaxWidth()) { + Text( + listOfNotNull(session.kind, session.host, session.model).joinToString(" · "), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.weight(1f), + ) + Text( + relativeTime(session.lastActivity), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } +} + +@Composable +fun StatusText(status: String) { + val (label, color) = when (status) { + "awaitingInput" -> "your turn" to AWAITING_COLOR + "running" -> "running" to RUNNING_COLOR + "compacting" -> "compacting" to RUNNING_COLOR + "exited" -> "exited" to MaterialTheme.colorScheme.onSurfaceVariant + else -> status to MaterialTheme.colorScheme.onSurfaceVariant + } + Row(verticalAlignment = Alignment.CenterVertically) { + if (status == "running" || status == "compacting") { + CircularProgressIndicator(modifier = Modifier.width(14.dp).height(14.dp), strokeWidth = 2.dp) + Spacer(Modifier.width(6.dp)) + } + Text(label, style = MaterialTheme.typography.labelLarge, color = color) + } +} + +fun relativeTime(epochSeconds: Double): String { + val seconds = (System.currentTimeMillis() / 1000.0 - epochSeconds).toLong() + return when { + seconds < 60 -> "just now" + seconds < 3600 -> "${seconds / 60}m ago" + seconds < 86400 -> "${seconds / 3600}h ago" + else -> "${seconds / 86400}d ago" + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/SessionScreen.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/SessionScreen.kt new file mode 100644 index 0000000..1959f97 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/SessionScreen.kt @@ -0,0 +1,349 @@ +package com.example.aiapp + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import java.util.concurrent.atomic.AtomicLong +import java.util.concurrent.atomic.AtomicReference + +private const val RECONNECT_DELAY_MS = 1500L + +/** + * What the transcript renders: the event stream folded into displayable + * rows (see [foldEvent]). The stream is the only data source -- opening + * this screen replays from seq 0, and a reconnect resumes from the last + * seq seen, so there is no separate history fetch to drift from it. + */ +sealed class TranscriptItem { + data class UserMsg(val text: String) : TranscriptItem() + data class AssistantMsg(val text: String) : TranscriptItem() + data class ToolRun( + val id: String, + val tool: String, + val input: String, + val output: String, + val done: Boolean, + ) : TranscriptItem() + data class QuestionCard( + val id: String, + val prompt: String, + val options: List, + val answer: String?, + ) : TranscriptItem() + data class ErrorMsg(val message: String) : TranscriptItem() + /** Placeholder row for events this build can't render (images, newer kinds). */ + data class Note(val text: String) : TranscriptItem() +} + +fun foldEvent(items: List, event: SessionEvent): List = + when (event) { + is SessionEvent.UserMessage -> items + TranscriptItem.UserMsg(event.text) + is SessionEvent.AssistantText -> { + // Deltas accumulate into the message they're streaming. + val last = items.lastOrNull() + if (last is TranscriptItem.AssistantMsg) { + items.dropLast(1) + last.copy(text = last.text + event.delta) + } else { + items + TranscriptItem.AssistantMsg(event.delta) + } + } + is SessionEvent.ToolStart -> + items + TranscriptItem.ToolRun(event.id, event.tool, event.input, "", done = false) + is SessionEvent.ToolUpdate -> + updateTool(items, event.id) { it.copy(output = event.output) } + is SessionEvent.ToolEnd -> + updateTool(items, event.id) { it.copy(output = event.output, done = true) } + is SessionEvent.Question -> + items + TranscriptItem.QuestionCard(event.id, event.prompt, event.options, answer = null) + is SessionEvent.Answered -> items.map { + if (it is TranscriptItem.QuestionCard && it.id == event.id) it.copy(answer = event.answer) else it + } + is SessionEvent.Error -> items + TranscriptItem.ErrorMsg(event.message) + is SessionEvent.Image -> items + TranscriptItem.Note("[image ${event.ref}]") + is SessionEvent.Unknown -> items + TranscriptItem.Note("[${event.type}]") + // Screen-level state, not transcript rows -- see SessionScreen. + is SessionEvent.Status, is SessionEvent.UsageDelta -> items + } + +private fun updateTool( + items: List, + id: String, + change: (TranscriptItem.ToolRun) -> TranscriptItem.ToolRun, +): List = items.map { + if (it is TranscriptItem.ToolRun && it.id == id) change(it) else it +} + +@Composable +fun SessionScreen(settings: ServerSettings, summary: SessionSummary, onBack: () -> Unit) { + val scope = rememberCoroutineScope() + var items by remember { mutableStateOf(listOf()) } + var status by remember { mutableStateOf(summary.status) } + var totalTokens by remember { mutableStateOf(0L) } + var streamError by remember { mutableStateOf(null) } + var actionError by remember { mutableStateOf(null) } + var input by remember { mutableStateOf("") } + var expandedTools by remember { mutableStateOf(setOf()) } + // The resume cursor, written from the stream's IO thread. + val lastSeq = remember { AtomicLong(0) } + val activeStream = remember { AtomicReference(null) } + val listState = rememberLazyListState() + + fun apply(entry: SeqEvent) { + lastSeq.set(entry.seq) + when (val event = entry.event) { + is SessionEvent.Status -> status = event.state + is SessionEvent.UsageDelta -> totalTokens += event.tokens + else -> items = foldEvent(items, event) + } + } + + // The stream lifecycle: connect, follow, and on any drop reconnect + // from the cursor -- so a flaky link (or a backend restart) costs + // nothing but the gap's latency. + LaunchedEffect(summary.id) { + while (true) { + val stream = EventStream(settings, summary.id) + activeStream.set(stream) + try { + withContext(Dispatchers.IO) { + stream.run(lastSeq.get()) { entry -> + apply(entry) + streamError = null + } + } + } catch (e: ApiException) { + streamError = e.message + } finally { + stream.close() + } + delay(RECONNECT_DELAY_MS) + } + } + // Coroutine cancellation can't interrupt a blocking socket read; + // closing the stream is what unblocks it when this screen goes away. + DisposableEffect(summary.id) { + onDispose { activeStream.get()?.close() } + } + + LaunchedEffect(items.size) { + if (items.isNotEmpty()) listState.animateScrollToItem(items.size - 1) + } + + fun act(action: () -> Unit) { + scope.launch { + try { + withContext(Dispatchers.IO) { action() } + actionError = null + } catch (e: ApiException) { + actionError = e.message + } + } + } + + fun send() { + val text = input.trim() + if (text.isEmpty()) return + input = "" + act { sendMessage(settings, summary.id, text) } + } + + Column(Modifier.fillMaxSize()) { + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp), + ) { + TextButton(onClick = onBack) { Text("Back") } + Column(Modifier.weight(1f)) { + Text(summary.title, style = MaterialTheme.typography.titleMedium) + Text( + listOfNotNull( + summary.kind, + summary.model, + if (totalTokens > 0) "$totalTokens tok" else null, + ).joinToString(" · "), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + StatusText(status) + } + + (streamError ?: actionError)?.let { message -> + Text( + message, + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.bodySmall, + modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp), + ) + } + + LazyColumn( + state = listState, + modifier = Modifier.weight(1f).fillMaxWidth(), + contentPadding = androidx.compose.foundation.layout.PaddingValues(16.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { + itemsIndexed(items) { _, item -> + when (item) { + is TranscriptItem.UserMsg -> UserBubble(item.text) + is TranscriptItem.AssistantMsg -> Text(item.text, style = MaterialTheme.typography.bodyLarge) + is TranscriptItem.ToolRun -> ToolCard( + tool = item, + expanded = item.id in expandedTools, + onToggle = { + expandedTools = + if (item.id in expandedTools) expandedTools - item.id + else expandedTools + item.id + }, + ) + is TranscriptItem.QuestionCard -> QuestionRow(item) { answer -> + act { answerQuestion(settings, summary.id, item.id, answer) } + } + is TranscriptItem.ErrorMsg -> Text( + item.message, + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.bodyMedium, + ) + is TranscriptItem.Note -> Text( + item.text, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } + + // Always enabled -- a send while the session is running becomes a + // steering message injected at the next tool boundary, which is + // the point of the whole app. + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth().padding(8.dp), + ) { + OutlinedTextField( + value = input, + onValueChange = { input = it }, + modifier = Modifier.weight(1f), + placeholder = { Text("Message") }, + maxLines = 4, + ) + Spacer(Modifier.width(8.dp)) + if (status == "running" || status == "compacting") { + OutlinedButton(onClick = { act { interruptSession(settings, summary.id) } }) { + Text("Stop") + } + Spacer(Modifier.width(8.dp)) + } + Button(onClick = { send() }) { Text("Send") } + } + } +} + +@Composable +private fun UserBubble(text: String) { + Box(Modifier.fillMaxWidth()) { + Card( + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.primaryContainer, + ), + modifier = Modifier.align(Alignment.CenterEnd).padding(start = 48.dp), + ) { + Text(text, modifier = Modifier.padding(12.dp)) + } + } +} + +/** + * Collapsed by default: name plus a spinner while running, expandable to + * the input and output. The spinner-while-unfinished is exactly "ToolStart + * with no matching ToolEnd yet". + */ +@Composable +private fun ToolCard(tool: TranscriptItem.ToolRun, expanded: Boolean, onToggle: () -> Unit) { + Card(Modifier.fillMaxWidth().clickable(onClick = onToggle)) { + Column(Modifier.padding(12.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text(tool.tool, style = MaterialTheme.typography.titleSmall, modifier = Modifier.weight(1f)) + if (!tool.done) { + CircularProgressIndicator( + modifier = Modifier.width(16.dp).height(16.dp), + strokeWidth = 2.dp, + ) + } + } + if (expanded) { + Spacer(Modifier.height(8.dp)) + Text("Input", style = MaterialTheme.typography.labelSmall) + Text(tool.input, style = MaterialTheme.typography.bodySmall) + if (tool.output.isNotEmpty()) { + Spacer(Modifier.height(8.dp)) + Text("Output", style = MaterialTheme.typography.labelSmall) + Text(tool.output, style = MaterialTheme.typography.bodySmall) + } + } + } + } +} + +/** + * A question (or permission request -- same shape) inline in the + * transcript. Option buttons until answered; then the chosen answer, which + * the `answered` event also resolves on every other connected device. + */ +@Composable +private fun QuestionRow(question: TranscriptItem.QuestionCard, onAnswer: (String) -> Unit) { + Card(Modifier.fillMaxWidth()) { + Column(Modifier.padding(12.dp)) { + Text(question.prompt, style = MaterialTheme.typography.bodyLarge) + Spacer(Modifier.height(8.dp)) + if (question.answer != null) { + Text( + "Answered: ${question.answer}", + style = MaterialTheme.typography.labelLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + question.options.forEach { option -> + OutlinedButton(onClick = { onAnswer(option) }) { Text(option) } + } + } + } + } + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/SettingsScreen.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/SettingsScreen.kt new file mode 100644 index 0000000..bcc3f06 --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/SettingsScreen.kt @@ -0,0 +1,110 @@ +package com.example.aiapp + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp + +/** + * Server address and token. The normal path is scanning the server's + * terminal QR (which lands in MainActivity and never shows this screen); + * these fields are the fallback for typing the same three values by hand. + * [onBack] is null on first run, when there is nothing to go back to. + */ +@Composable +fun SettingsScreen( + existing: ServerSettings?, + onSaved: (ServerSettings) -> Unit, + onBack: (() -> Unit)?, +) { + val context = LocalContext.current + var host by remember { mutableStateOf(existing?.host ?: "10.66.0.1") } + var port by remember { mutableStateOf((existing?.port ?: 8443).toString()) } + // Never pre-filled from the stored token: this screen shouldn't be a + // way to read the credential back off the device. + var token by remember { mutableStateOf("") } + var error by remember { mutableStateOf(null) } + + Column(Modifier.fillMaxSize().padding(16.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text( + "Server", + style = MaterialTheme.typography.headlineSmall, + modifier = Modifier.weight(1f), + ) + if (onBack != null) { + TextButton(onClick = onBack) { Text("Back") } + } + } + Spacer(Modifier.height(8.dp)) + Text( + "The easy way: run ai-server on the backend and scan the QR it prints " + + "with the phone's camera. Or type the same values here.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(Modifier.height(16.dp)) + + OutlinedTextField( + value = host, + onValueChange = { host = it }, + label = { Text("Host") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(8.dp)) + OutlinedTextField( + value = port, + onValueChange = { port = it }, + label = { Text("Port") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(8.dp)) + OutlinedTextField( + value = token, + onValueChange = { token = it }, + label = { Text(if (existing != null) "Token (unchanged if left blank)" else "Token") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(24.dp)) + + error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + Spacer(Modifier.height(8.dp)) + } + + Button(onClick = { + val portNumber = port.trim().toIntOrNull() + val effectiveToken = token.trim().ifEmpty { existing?.token ?: "" } + when { + host.isBlank() -> error = "Host is required" + portNumber == null || portNumber !in 1..65535 -> error = "Port must be 1-65535" + effectiveToken.isEmpty() -> error = "Token is required -- scan the server's QR or paste it" + else -> { + val settings = ServerSettings(host.trim(), portNumber, effectiveToken) + saveServerSettings(context, settings) + onSaved(settings) + } + } + }) { Text("Save") } + } +} diff --git a/app/androidApp/src/main/kotlin/com/example/aiapp/SpawnScreen.kt b/app/androidApp/src/main/kotlin/com/example/aiapp/SpawnScreen.kt new file mode 100644 index 0000000..82e3b6c --- /dev/null +++ b/app/androidApp/src/main/kotlin/com/example/aiapp/SpawnScreen.kt @@ -0,0 +1,105 @@ +package com.example.aiapp + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.FilterChip +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +// The session kinds this build can spawn. Phase 2 adds "claude" (with +// model / working directory / permission-mode fields), phase 4 "pi" -- +// extending this list and the per-kind fields, not adding a parallel +// screen. +private val KINDS = listOf("echo") + +/** The spawn screen: kind, title, go. */ +@Composable +fun SpawnScreen( + settings: ServerSettings, + onSpawned: (SessionSummary) -> Unit, + onBack: () -> Unit, +) { + val scope = rememberCoroutineScope() + var kind by remember { mutableStateOf(KINDS.first()) } + var title by remember { mutableStateOf("") } + var busy by remember { mutableStateOf(false) } + var error by remember { mutableStateOf(null) } + + Column(Modifier.fillMaxSize().padding(16.dp)) { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text( + "New session", + style = MaterialTheme.typography.headlineSmall, + modifier = Modifier.weight(1f), + ) + TextButton(onClick = onBack) { Text("Cancel") } + } + Spacer(Modifier.height(16.dp)) + + Text("Kind", style = MaterialTheme.typography.labelLarge) + Row { + KINDS.forEach { candidate -> + FilterChip( + selected = kind == candidate, + onClick = { kind = candidate }, + label = { Text(candidate) }, + ) + Spacer(Modifier.height(0.dp)) + } + } + Spacer(Modifier.height(16.dp)) + + OutlinedTextField( + value = title, + onValueChange = { title = it }, + label = { Text("Title") }, + placeholder = { Text("Echo session") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(24.dp)) + + error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + Spacer(Modifier.height(8.dp)) + } + + Button( + onClick = { + busy = true + scope.launch { + try { + val spawned = withContext(Dispatchers.IO) { + spawnSession(settings, kind, title.trim()) + } + onSpawned(spawned) + } catch (e: ApiException) { + error = e.message + busy = false + } + } + }, + enabled = !busy, + ) { Text(if (busy) "Spawning..." else "Spawn") } + } +} diff --git a/app/build.gradle.kts b/app/build.gradle.kts new file mode 100644 index 0000000..d49e685 --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,5 @@ +plugins { + alias(libs.plugins.androidApplication) apply false + alias(libs.plugins.composeMultiplatform) apply false + alias(libs.plugins.composeCompiler) apply false +} diff --git a/app/gradle.properties b/app/gradle.properties new file mode 100644 index 0000000..35a9610 --- /dev/null +++ b/app/gradle.properties @@ -0,0 +1,7 @@ +org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8 +org.gradle.parallel=true +org.gradle.caching=true +org.gradle.configuration-cache=true +kotlin.code.style=official +android.useAndroidX=true +android.nonTransitiveRClass=true diff --git a/app/gradle/libs.versions.toml b/app/gradle/libs.versions.toml new file mode 100644 index 0000000..9d37cf0 --- /dev/null +++ b/app/gradle/libs.versions.toml @@ -0,0 +1,23 @@ +# Latest stable versions as of 2026-08-24 (checked against Google Maven / +# Maven Central; prereleases deliberately skipped). +[versions] +agp = "9.3.2" +kotlin = "2.4.10" +compose-multiplatform = "1.11.1" +# material3 ships on its own release train, separate from the CMP version. +compose-material3 = "1.9.0" +androidx-activityCompose = "1.13.0" + +[libraries] +androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activityCompose" } +# Declared directly rather than through the plugin's `compose.*` accessors, +# which are deprecated as of CMP 1.11. +compose-runtime = { module = "org.jetbrains.compose.runtime:runtime", version.ref = "compose-multiplatform" } +compose-foundation = { module = "org.jetbrains.compose.foundation:foundation", version.ref = "compose-multiplatform" } +compose-material3 = { module = "org.jetbrains.compose.material3:material3", version.ref = "compose-material3" } +compose-ui = { module = "org.jetbrains.compose.ui:ui", version.ref = "compose-multiplatform" } + +[plugins] +androidApplication = { id = "com.android.application", version.ref = "agp" } +composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" } +composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } diff --git a/app/gradle/wrapper/gradle-wrapper.jar b/app/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..eddabd2eef8d94a5437d6168ff9c87a78ff725b3 GIT binary patch literal 47505 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 '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/app/gradlew.bat b/app/gradlew.bat new file mode 100644 index 0000000..7e60b72 --- /dev/null +++ b/app/gradlew.bat @@ -0,0 +1,82 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem gradlew startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables, and ensure extensions are enabled +setlocal EnableExtensions + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS=-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:execute +@rem Setup the command line + + + +@rem Execute gradlew +@rem endlocal doesn't take effect until after the line is parsed and variables are expanded +@rem which allows us to clear the local environment before executing the java command +endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel + +:exitWithErrorLevel +@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts +"%COMSPEC%" /c exit %ERRORLEVEL% diff --git a/app/run-android.sh b/app/run-android.sh new file mode 100755 index 0000000..c85e9f5 --- /dev/null +++ b/app/run-android.sh @@ -0,0 +1,106 @@ +#!/bin/sh +# Builds and runs this app on an emulator, creating/booting the AVD first if +# it isn't already up. Same flow as local-updater's run-android.sh; see that +# script for the reasoning behind the avd handling. +# +# Environment setup (SDK location, PATH, ...) lives in ./android-env.sh, +# which can also be sourced directly for one-off commands. +set -eu + +APP_ID="com.example.aiapp" + +# The AVD shared by this machine's Android projects -- one emulator, not +# one per repo. Override with AVD_NAME=... elsewhere. +AVD_NAME="${AVD_NAME:-tdep}" +DEVICE_PROFILE="${DEVICE_PROFILE:-pixel_10}" +SYSTEM_IMAGE="${SYSTEM_IMAGE:-system-images;android-36;google_apis;x86_64}" + +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd) +cd "$SCRIPT_DIR" + +# shellcheck source=./android-env.sh +. ./android-env.sh + +# Prints the adb serial of a running instance of AVD "$1", or nothing. +avd_serial() { + for s in $(adb devices | awk '$2 == "device" {print $1}'); do + if [ "$(adb -s "$s" emu avd name 2>/dev/null | head -n1 | tr -d '\r')" = "$1" ]; then + echo "$s" + return 0 + fi + done +} + +echo "==> Ensuring emulator system image is installed" +android sdk install emulator "$SYSTEM_IMAGE" || echo " (non-fatal: see above)" + +if [ ! -f "$ANDROID_AVD_HOME/$AVD_NAME.ini" ]; then + echo "==> Creating AVD '$AVD_NAME' ($DEVICE_PROFILE, $SYSTEM_IMAGE)" + echo no | avdmanager create avd \ + -n "$AVD_NAME" \ + -k "$SYSTEM_IMAGE" \ + --device "$DEVICE_PROFILE" \ + --sdcard 512M +else + echo "==> Reusing existing AVD '$AVD_NAME'" +fi + +# Host keyboard into the emulator -- this app has text fields. +CONFIG_INI="$ANDROID_AVD_HOME/$AVD_NAME.avd/config.ini" +if [ -f "$CONFIG_INI" ]; then + grep -v '^hw\.keyboard=' "$CONFIG_INI" >"$CONFIG_INI.tmp" + echo "hw.keyboard=yes" >>"$CONFIG_INI.tmp" + mv "$CONFIG_INI.tmp" "$CONFIG_INI" +fi + +SERIAL=$(avd_serial "$AVD_NAME") +if [ -n "$SERIAL" ]; then + echo "==> Emulator '$AVD_NAME' already running ($SERIAL)" +else + # Clean up a stray/crashed process for this AVD, if any. The bracketed + # first character keeps the pattern from matching the shell running + # this script -- unbracketed, this kills that shell mid-run. + pkill -f "[e]mulator.*-avd $AVD_NAME" >/dev/null 2>&1 || true + + EMU_LOG="/tmp/$AVD_NAME-emulator.log" + : >"$EMU_LOG" + if [ -n "${DISPLAY:-}" ] || [ -n "${WAYLAND_DISPLAY:-}" ]; then + echo "==> Starting emulator '$AVD_NAME' with GPU acceleration (-gpu host)" + emulator -avd "$AVD_NAME" -gpu host -no-audio >"$EMU_LOG" 2>&1 & + else + echo "==> No display -- starting emulator '$AVD_NAME' headless (-gpu swiftshader_indirect)" + emulator -avd "$AVD_NAME" -gpu swiftshader_indirect -no-audio -no-window \ + >"$EMU_LOG" 2>&1 & + fi + EMU_PID=$! + + i=0 + booted="" + while [ "$i" -lt 150 ]; do + if ! kill -0 "$EMU_PID" 2>/dev/null; then + echo "Emulator process exited unexpectedly. Log output:" >&2 + cat "$EMU_LOG" >&2 + exit 1 + fi + SERIAL=$(avd_serial "$AVD_NAME") + if [ -n "$SERIAL" ]; then + booted=$(adb -s "$SERIAL" shell getprop sys.boot_completed 2>/dev/null | tr -d '\r') + [ "$booted" = "1" ] && break + fi + i=$((i + 1)) + sleep 2 + done + if [ "$booted" != "1" ]; then + echo "Emulator did not finish booting in time. Log output:" >&2 + cat "$EMU_LOG" >&2 + exit 1 + fi +fi + +echo "==> Building debug APK" +./gradlew :androidApp:assembleDebug + +APK="androidApp/build/outputs/apk/debug/androidApp-debug.apk" +echo "==> Installing and launching $APK" +adb -s "$SERIAL" install -r "$APK" +adb -s "$SERIAL" shell am start -n "$APP_ID/.MainActivity" diff --git a/app/settings.gradle.kts b/app/settings.gradle.kts new file mode 100644 index 0000000..2ead5d4 --- /dev/null +++ b/app/settings.gradle.kts @@ -0,0 +1,18 @@ +rootProject.name = "AiApp" + +pluginManagement { + repositories { + google() + gradlePluginPortal() + mavenCentral() + } +} + +dependencyResolutionManagement { + repositories { + google() + mavenCentral() + } +} + +include(":androidApp")