The phone as an OxygenFlow runner, first part (refs #8) 4aee5293461d

Account -> OxygenFlow runner -> Offer this phone as a runner: a one-time
token from the hub (POST /api/v1/user/runner-token), then OxygenFlow's
own runner registers the phone for the account's repositories (label
android, the WASM tier) and runs in a foreground service while the
phone is charging on Wi-Fi; leaving either drains it. OxygenFlow is a
subrepo (oxygenflow/), linked through rust-core (runner_register,
runner_serve, runner_stop, runner_tiers), whose oxy-core is now the one
OxygenFlow pins; the runner runs WASM modules in a thread (wasmtime).
Manifest: the service (specialUse, typed from Android 14), network
state, notifications. Test for the token call; 76 tests, lint clean.

Author: Andy McCall @andymccall <[email protected]>
via: agent agent:claude@andymccall <[email protected]> · keyless, under your grant for changes,refs,seal · key 24c72d58db55
When: 10 days ago · 2026-10-25 15:14 UTC
Signature: ◈ sealed by agent:claude@andymccall
Hash: 4aee5293461d15ee10023c9e9c81b017c1a8210b723d8f6b9eb3bdbb7c91543b
Depends on: 0381bd8af55e 0a2858c0dad3 144cbf7bf2b5 57c0824300db 5ae4af48ddd2 5e9b097535f7 d1f635be9442 db00632a61d6 e0e4a1c48a77 e2df27a81e5d
Depended on by: 263c6cad5e51 aa627197ec18 0b152017dee3 8440d51a2275 840c75813f86 1dfa631436b6 aa21eb5e0e5b e0004d61958c 26530d9758ee a49fd826e10b ed6c64d23fca 0414607973cb dfbc3e972872 fbc95ee8777c 1c42a70fcba3 e833eb0a9e7f 31e4f3755627 98dbd1220929 41e2e862abce 114865a07877 ff65ea456ff1 74bbbc259910
In bookmarks: main
In tags: v0.1.0 v0.1.1 v0.1.2 v0.1.3 v0.1.4 v0.1.5 v0.1.6 v0.1.7 v0.1.8 v0.1.9
Edits: 127 atoms, 5 tree operations, 17 files

Browse the tree at this change

hide whitespace changes

added app/src/main/java/io/oxygenhub/android/runner/PhoneRunner.kt +102 −0

added app/src/main/java/io/oxygenhub/android/runner/RunnerCard.kt +101 −0

added app/src/main/java/io/oxygenhub/android/runner/RunnerService.kt +133 −0

added oxygenflow +0 −0

No line changes.

modified .oxymodules +3 −0

modified CHANGELOG.md +1 −0

modified app/src/main/AndroidManifest.xml +14 −0

modified app/src/main/java/io/oxygenhub/android/api/HubClient.kt +5 −0

modified app/src/main/java/io/oxygenhub/android/api/Models.kt +7 −0

modified app/src/main/java/io/oxygenhub/android/ui/account/AccountScreen.kt +4 −1

modified app/src/main/java/io/oxygenhub/android/ui/nav/AppNavigation.kt +1 −1

modified app/src/screenshotTest/kotlin/io/oxygenhub/android/Screenshots.kt +2 −0

modified app/src/test/java/io/oxygenhub/android/FakeHubApi.kt +2 −0

modified app/src/test/java/io/oxygenhub/android/api/HubClientTest.kt +12 −0

modified rust-core/Cargo.lock +1638 −23

modified rust-core/Cargo.toml +5 −1

modified rust-core/src/lib.rs +66 −5

1	+	package io.oxygenhub.android.runner
2	+
3	+	import android.content.Context
4	+	import android.content.Intent
5	+	import android.net.ConnectivityManager
6	+	import android.net.NetworkCapabilities
7	+	import android.os.BatteryManager
8	+	import android.os.Build
9	+	import androidx.core.content.ContextCompat
10	+	import io.oxygenhub.android.api.HubApi
11	+	import kotlinx.coroutines.Dispatchers
12	+	import kotlinx.coroutines.flow.MutableStateFlow
13	+	import kotlinx.coroutines.flow.StateFlow
14	+	import kotlinx.coroutines.flow.asStateFlow
15	+	import kotlinx.coroutines.withContext
16	+	import uniffi.rust_core.runnerIsRegistered
17	+	import uniffi.rust_core.runnerRegister
18	+	import uniffi.rust_core.runnerStop
19	+	import java.io.File
20	+
21	+	/**
22	+	* The phone as an OxygenFlow runner (#8): OxygenFlow's own runner, built
23	+	* into the app through rust-core, offering the WASM tier. It runs in
24	+	* [RunnerService] only while the phone is on charge and on an unmetered
25	+	* network (Wi-Fi), and drains when either stops: it claims nothing more
26	+	* and finishes what it holds.
27	+	*/
28	+	object PhoneRunner {
29	+	sealed interface State {
30	+	data object Unregistered : State
31	+
32	+	/** Registered, not running. */
33	+	data object Stopped : State
34	+
35	+	/** Not allowed to run now, and why (off charge, off Wi-Fi). */
36	+	data class Waiting(val why: String) : State
37	+
38	+	data object Running : State
39	+
40	+	/** Told to stop: finishing what it holds. */
41	+	data class Draining(val why: String) : State
42	+
43	+	data class Failed(val message: String) : State
44	+	}
45	+
46	+	private val _state = MutableStateFlow<State>(State.Unregistered)
47	+	val state: StateFlow<State> = _state.asStateFlow()
48	+
49	+	internal fun set(state: State) {
50	+	_state.value = state
51	+	}
52	+
53	+	/** Where the runner keeps its credential and its jobs' files. */
54	+	fun home(context: Context): File = File(context.filesDir, "flow").also { it.mkdirs() }
55	+
56	+	/** Called when the app starts and the service ends: what the runner is, as far as this process knows. */
57	+	fun refresh(context: Context) {
58	+	val now = _state.value
59	+	if (now is State.Running \|\| now is State.Draining) return
60	+	_state.value = if (runnerIsRegistered(home(context).path)) {
61	+	if (now is State.Waiting \|\| now is State.Failed) now else State.Stopped
62	+	} else {
63	+	State.Unregistered
64	+	}
65	+	}
66	+
67	+	/** The runner's name on the hub: the phone's model, as runner names are written. */
68	+	fun name(): String =
69	+	"android-" + Build.MODEL.lowercase().replace(Regex("[^a-z0-9]+"), "-").trim('-').ifEmpty { "phone" }
70	+
71	+	/** Ask the hub for a token and register this phone as a runner for the account's repositories. */
72	+	suspend fun register(context: Context, api: HubApi, hub: String): String {
73	+	val token = api.runnerToken()
74	+	val name = withContext(Dispatchers.IO) { runnerRegister(home(context).path, hub, token.token, name()) }
75	+	_state.value = State.Stopped
76	+	return name
77	+	}
78	+
79	+	/** Why the runner may not run now, or null when it may: on charge and on Wi-Fi. */
80	+	fun blockedBy(context: Context): String? {
81	+	val battery = context.getSystemService(BatteryManager::class.java)
82	+	if (battery != null && !battery.isCharging) return "the phone is not on charge"
83	+	val net = context.getSystemService(ConnectivityManager::class.java)
84	+	val caps = net?.activeNetwork?.let { net.getNetworkCapabilities(it) }
85	+	if (caps == null \|\| !caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)) {
86	+	return "the phone is not on Wi-Fi (or another unmetered network)"
87	+	}
88	+	return null
89	+	}
90	+
91	+	fun start(context: Context) {
92	+	ContextCompat.startForegroundService(context, Intent(context, RunnerService::class.java))
93	+	}
94	+
95	+	/** Drain: claim nothing more, finish and report what it holds, then stop. */
96	+	fun drain(why: String) {
97	+	if (_state.value == State.Running) {
98	+	_state.value = State.Draining(why)
99	+	runnerStop()
100	+	}
101	+	}
102	+	}

1	+	package io.oxygenhub.android.runner
2	+
3	+	import android.Manifest
4	+	import android.content.pm.PackageManager
5	+	import android.os.Build
6	+	import androidx.activity.compose.rememberLauncherForActivityResult
7	+	import androidx.activity.result.contract.ActivityResultContracts
8	+	import androidx.compose.foundation.layout.Arrangement
9	+	import androidx.compose.foundation.layout.Column
10	+	import androidx.compose.foundation.layout.Row
11	+	import androidx.compose.foundation.layout.fillMaxWidth
12	+	import androidx.compose.foundation.layout.padding
13	+	import androidx.compose.material3.Button
14	+	import androidx.compose.material3.ElevatedCard
15	+	import androidx.compose.material3.MaterialTheme
16	+	import androidx.compose.material3.OutlinedButton
17	+	import androidx.compose.material3.Text
18	+	import androidx.compose.runtime.Composable
19	+	import androidx.compose.runtime.LaunchedEffect
20	+	import androidx.compose.runtime.getValue
21	+	import androidx.compose.runtime.mutableStateOf
22	+	import androidx.compose.runtime.remember
23	+	import androidx.compose.runtime.rememberCoroutineScope
24	+	import androidx.compose.runtime.setValue
25	+	import androidx.compose.ui.Modifier
26	+	import androidx.compose.ui.platform.LocalContext
27	+	import androidx.compose.ui.unit.dp
28	+	import androidx.core.content.ContextCompat
29	+	import androidx.lifecycle.compose.collectAsStateWithLifecycle
30	+	import io.oxygenhub.android.api.HubApi
31	+	import io.oxygenhub.android.api.userMessage
32	+	import io.oxygenhub.android.ui.theme.LocalStatusColors
33	+	import kotlinx.coroutines.CancellationException
34	+	import kotlinx.coroutines.launch
35	+
36	+	/**
37	+	* The phone as an OxygenFlow runner (#8), on the Account screen: offer it
38	+	* (one tap: a registration token from the hub, then the runner starts),
39	+	* see what it is doing, stop it.
40	+	*/
41	+	@Composable
42	+	fun RunnerCard(api: HubApi, hub: String, canWrite: Boolean) {
43	+	val context = LocalContext.current
44	+	val state by PhoneRunner.state.collectAsStateWithLifecycle()
45	+	var busy by remember { mutableStateOf(false) }
46	+	var error by remember { mutableStateOf<String?>(null) }
47	+	val scope = rememberCoroutineScope()
48	+	LaunchedEffect(Unit) { PhoneRunner.refresh(context) }
49	+	// The notification that says the runner works; the runner runs without it too.
50	+	val ask = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { PhoneRunner.start(context) }
51	+	val start = {
52	+	val granted = Build.VERSION.SDK_INT < 33 \|\|
53	+	ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
54	+	if (granted) PhoneRunner.start(context) else ask.launch(Manifest.permission.POST_NOTIFICATIONS)
55	+	}
56	+	val status = LocalStatusColors.current
57	+	ElevatedCard(Modifier.fillMaxWidth()) {
58	+	Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
59	+	Text("OxygenFlow runner", style = MaterialTheme.typography.titleMedium)
60	+	val (line, colour) = when (val s = state) {
61	+	PhoneRunner.State.Unregistered -> "Run your repositories' WASM jobs on this phone, while it is charging on Wi-Fi." to MaterialTheme.colorScheme.onSurfaceVariant
62	+	PhoneRunner.State.Stopped -> "Registered as ${PhoneRunner.name()}; not running." to MaterialTheme.colorScheme.onSurfaceVariant
63	+	is PhoneRunner.State.Waiting -> "Not running: ${s.why}." to MaterialTheme.colorScheme.onSurfaceVariant
64	+	PhoneRunner.State.Running -> "Running as ${PhoneRunner.name()}: taking WASM jobs." to status.ok
65	+	is PhoneRunner.State.Draining -> "Draining (${s.why}): finishing its job, then stopping." to status.warn
66	+	is PhoneRunner.State.Failed -> "Stopped: ${s.message}" to status.bad
67	+	}
68	+	Text(line, style = MaterialTheme.typography.bodyMedium, color = colour)
69	+	error?.let { Text(it, style = MaterialTheme.typography.bodyMedium, color = status.bad) }
70	+	Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
71	+	when (state) {
72	+	PhoneRunner.State.Unregistered -> Button(
73	+	enabled = canWrite && !busy,
74	+	onClick = {
75	+	busy = true
76	+	error = null
77	+	scope.launch {
78	+	try {
79	+	PhoneRunner.register(context, api, hub)
80	+	start()
81	+	} catch (e: CancellationException) {
82	+	throw e
83	+	} catch (e: Exception) {
84	+	error = e.userMessage()
85	+	} finally {
86	+	busy = false
87	+	}
88	+	}
89	+	},
90	+	) { Text("Offer this phone as a runner") }
91	+	PhoneRunner.State.Running -> OutlinedButton(onClick = { PhoneRunner.drain("stopped by you") }) { Text("Stop") }
92	+	is PhoneRunner.State.Draining -> {}
93	+	else -> Button(onClick = { start() }) { Text("Start") }
94	+	}
95	+	}
96	+	if (!canWrite && state == PhoneRunner.State.Unregistered) {
97	+	Text("Sign in again to allow it: offering a runner needs repo:write.", style = MaterialTheme.typography.bodySmall)
98	+	}
99	+	}
100	+	}
101	+	}

1	+	package io.oxygenhub.android.runner
2	+
3	+	import android.app.Notification
4	+	import android.app.NotificationChannel
5	+	import android.app.NotificationManager
6	+	import android.app.PendingIntent
7	+	import android.app.Service
8	+	import android.content.BroadcastReceiver
9	+	import android.content.Context
10	+	import android.content.Intent
11	+	import android.content.IntentFilter
12	+	import android.content.pm.ServiceInfo
13	+	import android.net.ConnectivityManager
14	+	import android.net.Network
15	+	import android.net.NetworkCapabilities
16	+	import android.os.Build
17	+	import android.os.IBinder
18	+	import io.oxygenhub.android.MainActivity
19	+	import io.oxygenhub.android.R
20	+	import uniffi.rust_core.runnerServe
21	+	import uniffi.rust_core.runnerStop
22	+
23	+	/**
24	+	* Runs the phone's OxygenFlow runner (#8) in the foreground, with a
25	+	* notification saying so, while the phone is on charge and on Wi-Fi.
26	+	* Leaving the charger or the network drains it: it claims nothing more,
27	+	* finishes and reports the job it holds, and the service stops.
28	+	*/
29	+	class RunnerService : Service() {
30	+	private var serving: Thread? = null
31	+	private var connectivity: ConnectivityManager.NetworkCallback? = null
32	+
33	+	private val power = object : BroadcastReceiver() {
34	+	override fun onReceive(context: Context, intent: Intent) {
35	+	PhoneRunner.drain("taken off charge")
36	+	notify("Draining: taken off charge")
37	+	}
38	+	}
39	+
40	+	override fun onBind(intent: Intent?): IBinder? = null
41	+
42	+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
43	+	// The special-use type is Android 14's; before it, the manifest's type stands.
44	+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
45	+	startForeground(NOTIFICATION, notification("Starting"), ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE)
46	+	} else {
47	+	startForeground(NOTIFICATION, notification("Starting"))
48	+	}
49	+	if (serving != null) return START_NOT_STICKY
50	+	val blocked = PhoneRunner.blockedBy(this)
51	+	if (blocked != null) {
52	+	PhoneRunner.set(PhoneRunner.State.Waiting(blocked))
53	+	stopSelf()
54	+	return START_NOT_STICKY
55	+	}
56	+	registerReceiver(power, IntentFilter(Intent.ACTION_POWER_DISCONNECTED))
57	+	watchNetwork()
58	+	val home = PhoneRunner.home(this).path
59	+	PhoneRunner.set(PhoneRunner.State.Running)
60	+	notify("Waiting for WASM jobs, on charge and Wi-Fi")
61	+	serving = Thread {
62	+	try {
63	+	runnerServe(home)
64	+	if (PhoneRunner.state.value !is PhoneRunner.State.Waiting) PhoneRunner.set(PhoneRunner.State.Stopped)
65	+	} catch (e: Exception) {
66	+	PhoneRunner.set(PhoneRunner.State.Failed(e.message ?: "the runner stopped"))
67	+	} finally {
68	+	serving = null
69	+	stopSelf()
70	+	}
71	+	}.apply {
72	+	name = "oxygenflow-runner"
73	+	start()
74	+	}
75	+	return START_NOT_STICKY
76	+	}
77	+
78	+	/** Off Wi-Fi (or onto a metered network): drain. */
79	+	private fun watchNetwork() {
80	+	val net = getSystemService(ConnectivityManager::class.java) ?: return
81	+	val callback = object : ConnectivityManager.NetworkCallback() {
82	+	override fun onLost(network: Network) {
83	+	if (PhoneRunner.blockedBy(this@RunnerService) != null) {
84	+	PhoneRunner.drain("off Wi-Fi")
85	+	notify("Draining: off Wi-Fi")
86	+	}
87	+	}
88	+
89	+	override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) {
90	+	if (!caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)) {
91	+	PhoneRunner.drain("on a metered network")
92	+	notify("Draining: on a metered network")
93	+	}
94	+	}
95	+	}
96	+	net.registerDefaultNetworkCallback(callback)
97	+	connectivity = callback
98	+	}
99	+
100	+	override fun onDestroy() {
101	+	runCatching { unregisterReceiver(power) }
102	+	connectivity?.let { cb -> runCatching { getSystemService(ConnectivityManager::class.java)?.unregisterNetworkCallback(cb) } }
103	+	// Stopped from outside (the app, the system): drain rather than leave a job behind.
104	+	if (serving != null) runnerStop()
105	+	super.onDestroy()
106	+	}
107	+
108	+	private fun notify(text: String) {
109	+	getSystemService(NotificationManager::class.java)?.notify(NOTIFICATION, notification(text))
110	+	}
111	+
112	+	private fun notification(text: String): Notification {
113	+	val manager = getSystemService(NotificationManager::class.java)
114	+	manager?.createNotificationChannel(
115	+	NotificationChannel(CHANNEL, "OxygenFlow runner", NotificationManager.IMPORTANCE_LOW).apply {
116	+	description = "While this phone runs OxygenFlow jobs"
117	+	},
118	+	)
119	+	val open = PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE)
120	+	return Notification.Builder(this, CHANNEL)
121	+	.setSmallIcon(R.drawable.ic_launcher_monochrome)
122	+	.setContentTitle("OxygenFlow runner")
123	+	.setContentText(text)
124	+	.setContentIntent(open)
125	+	.setOngoing(true)
126	+	.build()
127	+	}
128	+
129	+	private companion object {
130	+	const val CHANNEL = "runner"
131	+	const val NOTIFICATION = 8
132	+	}
133	+	}

1	1		[oxygen]
2	2		url = https://oxygenhub.io/andymccall/oxygen
3	3
	4	+	[oxygenflow]
	5	+	url = https://oxygenhub.io/andymccall/oxygenflow
	6	+

		…	1 unchanged lines
2	2
3	3		## Unreleased
4	4
	5	+	- The phone as an OxygenFlow runner (#8, first part): Account → OxygenFlow runner → Offer this phone as a runner asks the hub for a one-time token (`POST /api/v1/user/runner-token`) and registers the phone as a runner for your own repositories, labelled `android`, offering the WASM tier. The runner is OxygenFlow's own, built into the app through rust-core (OxygenFlow is a subrepo, `oxygenflow/`, and rust-core's oxy-core is the one it pins), running WASM modules in a thread with wasmtime. It runs in a foreground service with a notification, only while the phone is charging on Wi-Fi (an unmetered network); coming off charge or off Wi-Fi drains it (it takes nothing more and finishes its job). Start and Stop on the card. The app is larger: the runner and wasmtime are about 29 MB per architecture.
5	6		- Proposals on the dashboard (#18): Waiting for your review (open proposals by others in your repositories you have not reviewed) and Your proposals (your open ones and drafts), as the hub's dashboard lists them, each opening the proposal screen where it can be landed. From the hub's `GET /api/v1/user/proposals`; a hub without it shows neither.
6	7		- Land proposals from the phone (#17): a repository has Issues and Proposals tabs; proposals open (with drafts), landed, closed or all, each saying whether it is ready to land, what stands in the way, or that it will land when its checks pass. A proposal shows the landing card (Land into the target, after a confirmation; land when its checks pass, on or off; the hub's blockers in its own words, and its reason when it refuses), then its checks (failures first, each opening its run), sealed approvals and asked reviewers, its changes and description. Landing needs `repo:write`, which sign-in now asks for: a phone signed in before this reads only, and says so with a button to sign in again rather than failing.
7	8		- A proper launcher icon (#15): OxygenHub's mark, the hub's two joined rings in its cyan-to-blue gradient, on the app's night navy with a soft glow, as an adaptive icon (any launcher's mask, inside the safe zone) with a monochrome layer for themed icons; the default robot's bitmaps are gone. A rendered preview is in `docs/screenshots/launcher-icon.png`.
		…	4 unchanged lines

		…	2 unchanged lines
3	3		xmlns:tools="http://schemas.android.com/tools">
4	4
5	5		<uses-permission android:name="android.permission.INTERNET" />
	6	+	<!-- The phone as an OxygenFlow runner (#8): a foreground service while it runs jobs,
	7	+	its notification, and the network's state for the Wi-Fi rule. -->
	8	+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
	9	+	<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
	10	+	<uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
	11	+	<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
6	12
7	13		<application
8	14		android:name=".OxygenHubApp"
		…	16 unchanged lines
25	31		<category android:name="android.intent.category.LAUNCHER" />
26	32		</intent-filter>
27	33		</activity>
	34	+	<service
	35	+	android:name=".runner.RunnerService"
	36	+	android:exported="false"
	37	+	android:foregroundServiceType="specialUse">
	38	+	<property
	39	+	android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
	40	+	android:value="Runs OxygenFlow CI jobs (WebAssembly) for the signed-in account while the phone is charging on Wi-Fi" />
	41	+	</service>
28	42		</application>
29	43
30	44		</manifest>

		…	55 unchanged lines
56	56		/** Land it by itself when its checks pass, or not (`repo:write`); the proposal after. */
57	57		suspend fun setAutoLand(owner: String, name: String, number: Long, on: Boolean): Proposal
58	58
	59	+	/** A one-time token registering this phone as a runner for the account's repositories (`repo:write`). */
	60	+	suspend fun runnerToken(): RunnerToken
	61	+
59	62		/** An account's picture (`/avatar/{name}`, public); null when the hub has none this app can draw. */
60	63		suspend fun avatar(name: String): Avatar?
61	64		}
		…	21 unchanged lines
83	86
84	87		override suspend fun inbox(limit: Int): Inbox =
85	88		get(url("notifications") { addQueryParameter("limit", limit.coerceIn(1, 200).toString()) }, Inbox.serializer())
	89	+
	90	+	override suspend fun runnerToken(): RunnerToken = send("POST", url("user", "runner-token"), RunnerToken.serializer())
86	91
87	92		override suspend fun userProposals(): UserProposals = get("user/proposals", UserProposals.serializer())
88	93
		…	109 unchanged lines

		…	139 unchanged lines
140	140		val name: String get() = repository.substringAfter('/')
141	141		}
142	142
	143	+	/** `POST /api/v1/user/runner-token`: a one-time token that registers a runner for [owner]'s repositories. */
	144	+	@Serializable
	145	+	data class RunnerToken(val token: String, val owner: String = "") {
	146	+	// The token is a secret until it is used.
	147	+	override fun toString(): String = "RunnerToken(owner=$owner, token=<redacted>)"
	148	+	}
	149	+
143	150		/** A change a proposal adds. */
144	151		@Serializable
145	152		data class ProposalChange(
		…	99 unchanged lines

		…	36 unchanged lines
37	37		import androidx.compose.ui.unit.dp
38	38		import io.oxygenhub.android.auth.Session
39	39		import io.oxygenhub.android.api.Avatar
	40	+	import io.oxygenhub.android.api.HubApi
	41	+	import io.oxygenhub.android.runner.RunnerCard
40	42		import io.oxygenhub.android.ui.common.AppScreen
41	43		import io.oxygenhub.android.ui.common.AvatarImage
42	44		import kotlinx.coroutines.launch
43	45
44	46		/** Who is signed in, to which hub, with what; and signing out. */
45	47		@Composable
46		-	fun AccountScreen(session: Session, avatar: Avatar?, nativeCore: () -> String, onSignOut: suspend () -> Unit) {
	48	+	fun AccountScreen(session: Session, avatar: Avatar?, api: HubApi, nativeCore: () -> String, onSignOut: suspend () -> Unit) {
47	49		var confirming by remember { mutableStateOf(false) }
48	50		var signingOut by remember { mutableStateOf(false) }
49	51		val scope = rememberCoroutineScope()
		…	10 unchanged lines
60	62		Spacer(Modifier.height(8.dp))
61	63		Text(session.username, style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
62	64		}
	65	+	RunnerCard(api, session.hub, session.canWrite)
63	66		Card(Modifier.fillMaxWidth()) {
64	67		ListItem(
65	68		leadingContent = { Icon(Icons.Outlined.Dns, contentDescription = null) },
		…	49 unchanged lines

		…	167 unchanged lines
168	168		)
169	169		}
170	170		composable<InboxRoute> { InboxScreen(inbox) }
171		-	composable<AccountRoute> { AccountScreen(session, rememberAvatar(api, session.username), nativeCore, onSignOut) }
	171	+	composable<AccountRoute> { AccountScreen(session, rememberAvatar(api, session.username), api, nativeCore, onSignOut) }
172	172		}
173	173		}
174	174		}
		…	9 unchanged lines

		…	96 unchanged lines
97	97		override suspend fun markAllRead() {}
98	98		override suspend fun revokeToken() {}
99	99
	100	+	override suspend fun runnerToken() = io.oxygenhub.android.api.RunnerToken("flowreg_sample", "ada")
	101	+
100	102		override suspend fun userProposals() = UserProposals(
101	103		review = listOf(ProposalBrief("babbage/difference-engine", 12, "Carry the tens with a ratchet", "babbage", updatedMs = now - 2 * hour)),
102	104		authored = listOf(ProposalBrief("ada/engine", 44, "Note G: loop the Bernoulli numbers", "ada", updatedMs = now - 5 * hour)),
		…	93 unchanged lines

		…	56 unchanged lines
57	57		calls += "read all"
58	58		markAllRead.invoke()
59	59		}
	60	+	var runnerToken: () -> io.oxygenhub.android.api.RunnerToken = { io.oxygenhub.android.api.RunnerToken("flowreg_test", "andymccall") }
	61	+	override suspend fun runnerToken() = runnerToken.invoke().also { calls += "runner token" }
60	62		override suspend fun userProposals() = userProposals.invoke().also { calls += "user proposals" }
61	63		override suspend fun proposals(owner: String, name: String, state: ProposalState): List<Proposal> =
62	64		proposals.invoke(state).also { calls += "proposals $owner/$name ${state.query}" }
		…	18 unchanged lines

		…	96 unchanged lines
97	97		}
98	98
99	99		@Test
	100	+	fun aRunnerTokenIsAskedForWithThePost() = runTest {
	101	+	server.enqueue(MockResponse().setResponseCode(201).setHeader("Content-Type", "application/json").setBody("""{"token":"flowreg_abc","owner":"andymccall"}"""))
	102	+	val t = client().runnerToken()
	103	+	assertEquals("andymccall", t.owner)
	104	+	assertEquals("flowreg_abc", t.token)
	105	+	assertFalse("the token is not printed", t.toString().contains("flowreg_abc"))
	106	+	val req = server.takeRequest()
	107	+	assertEquals("POST" to "/api/v1/user/runner-token", req.method to req.path)
	108	+	assertEquals("Bearer oxy_secret", req.getHeader("Authorization"))
	109	+	}
	110	+
	111	+	@Test
100	112		fun repositories() = runTest {
101	113		server.enqueue(json("repos.json"))
102	114		assertEquals(3, client().repositories().size)
		…	114 unchanged lines

		…	6 unchanged lines
7	7		crate-type = ["cdylib", "lib"]
8	8
9	9		[dependencies]
10		-	oxy-core = { path = "../oxygen/crates/oxy-core" }
	10	+	# Oxygen as OxygenFlow pins it, so the runner and this crate share one oxy-core.
	11	+	oxy-core = { path = "../oxygenflow/deps/oxygen/crates/oxy-core" }
	12	+	# OxygenFlow's runner, run in the app's own process (oxygenhub-android#8).
	13	+	flow = { path = "../oxygenflow/crates/flow" }
11	14		uniffi = { version = "0.28", features = ["cli"] }
	15	+	anyhow = "1"
12	16
13	17		[build-dependencies]
14	18		uniffi = { version = "0.28", features = ["build"] }

1	1		uniffi::setup_scaffolding!();
2	2
3		-	// A simple test function to ensure the Kotlin <-> Rust bridge is working
4		-	// We will eventually wrap oxy_core functions here.
	3	+	use std::path::Path;
	4	+
	5	+	// A simple test function to ensure the Kotlin <-> Rust bridge is working.
5	6		#[uniffi::export]
6	7		pub fn oxygen_greeting(name: String) -> String {
7	8		format!("Hello, {}! Oxygen Native Core is active.", name)
	9	+	}
	10	+
	11	+	/// Why a runner call failed, in OxygenFlow's words.
	12	+	#[derive(Debug, uniffi::Error)]
	13	+	pub enum RunnerError {
	14	+	Failed { reason: String },
	15	+	}
	16	+
	17	+	impl std::fmt::Display for RunnerError {
	18	+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	19	+	match self {
	20	+	RunnerError::Failed { reason } => f.write_str(reason),
	21	+	}
	22	+	}
	23	+	}
	24	+
	25	+	impl std::error::Error for RunnerError {}
	26	+
	27	+	fn failed(e: anyhow::Error) -> RunnerError {
	28	+	RunnerError::Failed { reason: format!("{e:#}") }
	29	+	}
	30	+
	31	+	/// The phone as an OxygenFlow runner (oxygenhub-android#8): OxygenFlow's
	32	+	/// own runner, built into the app, offering only the WASM tier. `home` is
	33	+	/// the app's directory for it; `register` keeps the runner's credential
	34	+	/// there (runner.toml), as `flow runner register` does on a host.
	35	+	#[uniffi::export]
	36	+	pub fn runner_register(home: String, hub: String, token: String, name: String) -> Result<String, RunnerError> {
	37	+	let h = flow::home::Home::locate(Some(Path::new(&home))).map_err(failed)?;
	38	+	let r = flow::runner::register(&h, &hub, &token, &name, None, vec!["android".into()]).map_err(failed)?;
	39	+	Ok(r.name)
8	40		}
9	41
10		-	// In the future, we can add functions like:
11		-	// #[uniffi::export]
12		-	// pub fn get_repo_status(path: String) -> StatusResult { ... }
	42	+	/// Whether `home` holds a registration, and so can serve.
	43	+	#[uniffi::export]
	44	+	pub fn runner_is_registered(home: String) -> bool {
	45	+	Path::new(&home).join(flow::home::RUNNER_TOML).is_file()
	46	+	}
	47	+
	48	+	/// Claim and run jobs until [`runner_stop`] drains the runner: returns
	49	+	/// once the jobs it holds are done and reported. Blocks, so call it from
	50	+	/// a thread of its own (the app's runner service).
	51	+	#[uniffi::export]
	52	+	pub fn runner_serve(home: String) -> Result<(), RunnerError> {
	53	+	let h = flow::home::Home::locate(Some(Path::new(&home))).map_err(failed)?;
	54	+	flow::runner::serve_embedded(&h).map_err(failed)
	55	+	}
	56	+
	57	+	/// Drain the runner: claim nothing more, finish and report what it
	58	+	/// holds, then [`runner_serve`] returns. For leaving the charger or the
	59	+	/// allowed network, or the owner stopping it.
	60	+	#[uniffi::export]
	61	+	pub fn runner_stop() {
	62	+	flow::runner::stop();
	63	+	}
	64	+
	65	+	/// The tiers this phone offers (the WASM tier), and why not the others.
	66	+	#[uniffi::export]
	67	+	pub fn runner_tiers(home: String) -> Vec<String> {
	68	+	let Ok(h) = flow::home::Home::locate(Some(Path::new(&home))) else { return vec![] };
	69	+	match flow::runner::tiers(&h) {
	70	+	Ok((have, _)) => have,
	71	+	Err(_) => vec![],
	72	+	}
	73	+	}

		…	2 unchanged lines
3	3		version = 4
4	4
5	5		[[package]]
	6	+	name = "addr2line"
	7	+	version = "0.26.1"
	8	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	9	+	checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
	10	+	dependencies = [
	11	+	"gimli",
	12	+	]
	13	+
	14	+	[[package]]
6	15		name = "adler2"
7	16		version = "2.0.1"
8	17		source = "registry+https://github.com/rust-lang/crates.io-index"
		…	9 unchanged lines
18	27		]
19	28
20	29		[[package]]
	30	+	name = "allocator-api2"
	31	+	version = "0.2.21"
	32	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	33	+	checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
	34	+
	35	+	[[package]]
	36	+	name = "ambient-authority"
	37	+	version = "0.0.2"
	38	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	39	+	checksum = "e9d4ee0d472d1cd2e28c97dfa124b3d8d992e10eb0a035f33f5d12e3a177ba3b"
	40	+
	41	+	[[package]]
21	42		name = "anstream"
22	43		version = "1.0.0"
23	44		source = "registry+https://github.com/rust-lang/crates.io-index"
		…	48 unchanged lines
72	93		version = "1.0.104"
73	94		source = "registry+https://github.com/rust-lang/crates.io-index"
74	95		checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
	96	+

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

The phone as an OxygenFlow runner, first part (refs #8) 4aee5293461d

Keyboard