@stim-cli/server 1.16.0 → 1.17.0

package/README.md

@@ -16,7 +16,7 @@ The design is in
 stim-server [--port <n>]          # serve paired clients, port 7787 by default
 stim-server pair [--port <n>] [--control]
                                   # print a single-use pairing payload
-stim-server devices [list]        # list paired devices, approved clients and access requests
+stim-server devices [list]        # list pairings, approvals, requests and hosted sessions
 stim-server devices grant <id> --control|--read|--build|--device-host
                                   # let a paired device run actions, or only read;
                                   # --build approves builds; --device-host approves device hosting
@@ -331,16 +331,15 @@ tokens.
 Device hosting has a separate `device-host` capability. An approved client can
 reserve, boot, reconnect to and stop its own iOS simulator or Android emulator
 through the protocol. It can deliver, install and launch a compatible iOS app
-bundle, Android APK or prebuilt macOS app, stream the iOS simulator or macOS app and control it. The hosted iOS
-app connects back to Metro on the client Mac. Automatic CLI placement and
-Android Metro and viewing remain in [#2266](https://github.com/appandflow/stim/issues/2266).
+bundle, Android APK or prebuilt macOS app, stream the iOS simulator, Android emulator or macOS app and control it. Hosted
+iOS and Android apps connect back to Metro on the client Mac. Automatic placement remains in [#2266](https://github.com/appandflow/stim/issues/2266).
 
 The Stim client can name expected hosts with
 `stim settings set hosting.machines '["<mac>"]'` and request access with
 `stim doctor --fix`. It stores a separate private credential in
 `$STIM_HOME/device-host-machines.json`, pins the worker's tailnet node, and
 reports approval under `deviceHosts` in doctor JSON. Plain doctor makes no
-approval request. This setup does not yet place CLI sessions remotely.
+approval request. Use `stim ios --remote <machine>` or `stim android --remote <machine>` for explicit placement.
 
 A client on the tailnet sends `hello` with
 `auth: { "request": "device-host", "deviceName": "Laptop" }`. As with a build
@@ -365,6 +364,31 @@ from phone pairings and build clients. A hosting token grants no `read`,
 read, control and build tokens cannot gain hosting through `devices grant`.
 Loopback requests and `pair --device-host` are refused.
 
+### Hosted here
+
+`stim-server devices` adds a **Hosted here** block after pairings and approvals,
+with the client name, platform, device label, installed app bundle id (or `-`),
+state and start time. `--json` adds `hostedSessions` next to `devices`, including
+an empty array when there are none. Rows are newest first; plain stopped
+sessions are omitted, while parked and unresolved sessions stay visible.
+A parked row uses its parking time. A removed client's name falls back to its id.
+The command reads the host journal directly and needs no server connection.
+
+`device-host.sessions` takes no params (or `{}`) and returns `{ sessions }`.
+Each row has `id`, `client: { id, name }`, `platform`, nullable `device` and `app`,
+`state`, `parked`, `since` (ISO time), and `workspace`.
+`device-host.sessions.stop` takes `{ "session": "<id>" }` and returns
+`{ "id": "<id>", "state": "stopping" | "stopped" }`. It stops any client's
+session through the existing stop path, closing Metro, view, agent and logs
+before owned-device teardown. Repeating a stopped session returns `stopped`;
+an absent id gets `unknown-session`.
+Both requests require an authenticated loopback Desktop connection with local
+identity and control access. Local read-only connections, paired phones and
+remote hosting clients get `forbidden`. A session whose active owner is not
+attached to this server reads as `unknown`; stop reconciles it through the same
+ownership checks. The approved-client `device-host.stop` remains limited to
+that client's own sessions.
+
 ### Hosted availability offers
 
 Before reserving, an approved hosting client can send:
@@ -572,7 +596,7 @@ session before starting another transfer. Manifest, file and partial blobs are s
 by attempts of one session in its content-addressed store; offers recheck complete
 blob digests and request only missing bytes.
 
-An iOS simulator or macOS session can take its content from a build this Mac ran instead: after
+An iOS simulator, Android emulator or macOS session can take its content from a build this Mac ran instead: after
 the manifest arrives, send `device-host.app.handoff` with
 `{session, attempt, build: {handoff, sha256}}`, where `handoff` is the token
 and `sha256` the archive digest from that job's `build.artifact` answer. The
@@ -583,7 +607,10 @@ declares links, whose directory resolves inside the staged bundle and whose
 bytes match their manifest digest; it answers `{files, bytes}` for what it
 took. The token is spent once the handoff starts. Re-offer and upload whatever
 is still missing; an older server answers `unknown-method`. For iOS, check the
-`hosted-ios-data` hello feature before requesting handoff; without it, upload.
+`hosted-ios-data` hello feature before requesting handoff; for Android check
+`hosted-android-data`. Without the feature, upload. Android takes only a regular
+APK file matching the single `App.apk` manifest entry. Handoff failure falls back
+to upload. Reused APK blobs skip transfer, while every new attempt still installs.
 
 After every digest is verified, call `device-host.app.launch` with
 `{session, attempt}`. Poll `device-host.app.attach` for `installed` or `unknown`.
@@ -619,11 +646,31 @@ signature or installation conflict refuses; hosting does not uninstall an
 existing app to resolve it.
 
 Release launch reports `true` only after observing a live package process.
-Development launch remains `unverified`; this driver launches the activity but
-does not wire an Android Metro bridge. Replaying an installed app attempt does
+Development launch remains `unverified` until the client Metro bridge provides
+bundle evidence. Replaying an installed app attempt does
 not install or launch again. Owner loss, stop, revocation and uncertain outcomes
-retain the same reconciliation rules as iOS. Android viewing, Metro and client
-placement remain under [#2266](https://github.com/appandflow/stim/issues/2266).
+retain the same reconciliation rules as iOS.
+
+With `hosting.agentDriver: agent-device`, each installed Android session gets
+its own daemon and child-aware claim under `device-host/sessions/<session>/agent-device.claims`.
+Both Macs need agent-device 0.21.22 or later. The host verifies the serial policy
+digest and `android-instance` backend and advertises `hosted-android-agent`.
+`device-host.app.attach` and session attach carry a session grant with
+`android:mobile:<serial>` and the same token and client-node checks as iOS.
+The client writes a 0600 remote config under `hosted-android/<slot>/` and reports
+it as `android.host.agent`. Use `agent-device <command> --remote-config <file>`.
+Missing or unsupported agent-device reports `driver: none` with its reason.
+
+The policy pins the ledger-owned serial and filters `devices` to that emulator.
+Inspection and interaction commands match iOS. Installs, reinstall, uninstall,
+boot/shutdown, `close --shutdown`, record, logs, uploads, other serials (including
+nested batches and leases), and host paths are refused. Ambient fields are
+stripped and replaced with host-owned platform, serial and lease scope.
+Stim installs apps. Android snapshots use one-shot helpers without adb forwards;
+after daemon exit the host stops and verifies only the two fixed agent-device
+helper packages on that serial. Their APKs leave with emulator deletion.
+Reinstall, stop, revocation and close await agent teardown before native work;
+unresolved agent claims refuse replacement and deletion after restart too.
 
 ### Hosted macOS app sessions
 
@@ -672,12 +719,12 @@ service despite the isolated home. Stop removes the app home and delivered bytes
 from every app attempt, keeping logs and receipts so `app.attach` can still report
 the recorded state.
 
-Once a macOS app is `installed`, `device-host.app.launch` and
+Once a hosted app is `installed`, `device-host.app.launch` and
 `device-host.app.attach` return the agent grant the host's driver issued for that
 session, or `agent: { driver: 'none' }` while no driver runs or it cannot scope
 the app; the driver's reason, if any, is the result's `notice`. The field is
 built for the response and never stored in the receipt or journal; it is absent
-before installation, after stop and for iOS and Android sessions. The worker
+before installation and after stop. The worker
 reports the app's pid, `DeviceHost` registers the running app with the agent
 driver before the receipt reads `installed`, and ends that registration when the
 session stops, is revoked or the server closes.
@@ -686,9 +733,19 @@ session stops, is revoked or the server closes.
 the NDJSON records the session's macOS app wrote to its captured log (stdout and
 stderr as `client` records, and its exit). iOS sessions capture app-filtered native
 logs as `device` records through bounded `simctl log show` worker queries, with
-a persisted time checkpoint in the isolated home. Windows adapt to the backlog,
+a persisted time checkpoint in the isolated home. Android sessions use
+`logcat -d -v epoch -T <epoch> --pid <pid>` on the exact ledger-owned serial after
+re-verifying its AVD name. Each collection resolves `pidof <package>` and also
+queries the last observed PID of that app attempt, to drain a crash or restart.
+Without any observed PID, logs cannot be attributed to the app. PID-based logcat
+cannot distinguish historical reuse of an exited PID. Output is bounded
+by the executor's 64 MiB limit per command and the collection's ten-second budget;
+an oversized query retries the recent tail and emits a `device` warning naming
+the dropped interval. Logcat entries already evicted from its finite buffer are
+unavailable. Both native collectors use the same checkpoint and NDJSON writer.
+Windows adapt to the backlog,
 overlap by five seconds and de-duplicate event identities. `checkpoint` is the last
-completed iOS window in epoch milliseconds. `log show` reads persisted entries;
+completed native window in epoch milliseconds. `log show` reads persisted entries;
 info-level entries and persistence delayed beyond the overlap may be unavailable.
 The worker holds a separate child-aware log claim. Queries coalesce onto an
 in-flight collection or read captured files; collection starts at most once every
@@ -713,8 +770,9 @@ byte offset after the last complete line read; pass the previous result's cursor
 receive only newer records, and repeat while `more` is true. Without a cursor, each
 file starts at most 4 MiB before its end. A page holds at most 1 MiB; a file that
 rotated since the cursor is read from the end of its previous generation. The
-session's own client only, for iOS and macOS sessions, and also after the session stopped,
-because stop keeps captured logs. iOS clients check hello feature `hosted-ios-data`;
+session's own client only, for iOS, Android and macOS sessions, and also after the session stopped,
+because stop keeps captured logs. iOS clients check hello feature `hosted-ios-data`
+and Android clients check `hosted-android-data`;
 without it, they show an update note and copied logs. Servers that predate macOS queries answer `forbidden` or
 `unknown-method`.
 
@@ -731,10 +789,18 @@ gateway accepts only that worker address and authenticates each connection
 before forwarding to the fixed local Metro port. It never targets a client
 supplied URL. Close the gateway when its session ends.
 
-Call `device-host.metro.open` with `{session, gatewayPort, secret}` on the
+Call `device-host.metro.open` with `{session, gatewayPort, secret, clientMetroPort?}` on the
 approved hosted connection. The server connects only to that connection's
 authenticated tailnet peer and returns `{port}` for the worker's loopback
-endpoint. Development installation uses that port for `RCT_jsLocation` and,
+endpoint. `clientMetroPort` is required for Android and validated as an integer
+from 1 through 65535. The session records it alongside the bridge port. Android
+development installation reverses `tcp:<clientMetroPort>` to `tcp:<port>` on
+the exact ledger-owned serial and sets `debug_http_host` to
+`localhost:<clientMetroPort>`. Reopening an installed development session runs
+a fixed reverse worker under its child-aware claim, serialized with install
+and stop, so a client reload restores the mapping after a host adb server
+restart. The worker never restarts the shared adb server. iOS development
+installation uses the bridge port for `RCT_jsLocation` and,
 when offered, the Expo development-client deep link. HTTP and WebSocket bytes
 stream over WireGuard with socket backpressure; no public tunnel, Funnel or
 Tailscale serve configuration change is needed. The 64 KiB server message
@@ -756,18 +822,23 @@ placement still needs to check that contract before selecting hosted Metro.
 Bare React Native uses the worker `RCT_jsLocation`. Bridge readiness and
 manifest requests are not launch proof; development remains `unverified` until
 the workspace observes the app's own bundle delivery.
-This is a protocol API for approved clients; automatic iOS CLI placement,
-Android Metro/viewing remains in [#2266](https://github.com/appandflow/stim/issues/2266).
+Approved clients use `stim ios|android --remote auto` for automatic device placement.
+They stay local while there is a free slot, no queued device run, normal memory
+pressure, no budget refusal and load below `offload.maxLoadPerCore`. Otherwise
+they rank compatible offers from `hosting.machines` and select a host, or wait
+locally if none admits. A reserve refusal after an offer fails with
+`STIM_HOSTING_REFUSED` and asks to retry; it does not re-place the built app.
+Automatic native macOS placement remains separate work.
 
 ### Hosted viewer relay
 
-The client's stim-server relays a hosted workspace's iOS simulator or macOS view and input to
+The client's stim-server relays a hosted workspace's iOS simulator, Android emulator or macOS view and input to
 its host using the client's approved device-host credential over the pinned
 tailnet connection. Stim Desktop and phones keep talking only to their own
-server. The `macos-hosted` and `ios-hosted` features advertise these relays.
-iOS resolves `ios.host` by the requested slot; macOS retains its default slot.
+server. The `macos-hosted`, `ios-hosted` and `android-hosted` features advertise these relays.
+iOS resolves `ios.host` and Android resolves `android.host` by the requested slot; macOS retains its default slot.
 The local platform and slot replace the host's private target fields in events
-and iOS control audit records. H.264 packets retain their flags and payload and
+and iOS/Android control audit records. H.264 packets retain their flags and payload and
 carry the local subscription ID, which identifies the platform and slot.
 The relay forwards iOS device artwork and orientation metadata. Hosted targets
 refuse replay (`at`/`rate`), `duoFrame` and `physical` with `bad-request`.
@@ -783,14 +854,14 @@ its packets until the next keyframe and, when the host advertises the
 `hosted-congestion` feature, sends `device-host.frames.congested` at most every
 250 ms, so the host lowers that app's bitrate as it does for a local subscriber
 whose socket backs up.
-Hosted macOS frames and control require the default slot; hosted iOS supports named slots.
+Hosted macOS frames and control require the default slot; hosted iOS and Android support named slots.
 `control.begin` still needs the local `control` grant. For macOS apps, Screen Recording for
 viewing and Accessibility for control are granted on the host, not the client.
 
-### Hosted iOS and macOS view and input
+### Hosted iOS, Android and macOS view and input
 
 An approved hosting client can subscribe to its ready session's exact owned
-iOS simulator or running macOS app without access to the worker's registered
+iOS simulator, Android emulator or running macOS app without access to the worker's registered
 workspaces:
 
 ```json
@@ -810,7 +881,7 @@ subscription ID as `params.subscription`. `device-host.frames.congested`
 behind on that H.264 subscription; it lowers the bitrate the same way a backed-up
 socket does.
 Hosted capture requires the compiled `stim-frames` helper and does not support
-replay, device artwork or screenshot fallback. macOS frames show only the one
+replay or screenshot fallback. iOS supports device artwork. macOS frames show only the one
 window of the hosted app. Viewing is refused before launch and after the app
 exits. On the hosting Mac, `stim-server service install` runs the server and
 `stim-frames` under Stim Host, whose Screen Recording and control grants they
@@ -820,13 +891,27 @@ System Audio Recording ends the stream; missing Device Control and Data Access
 (Accessibility on macOS 26 and earlier) leaves viewing available.
 See [Run as a service](#run-as-a-service) for the settings panes and Dev caveat.
 
+Android capture uses the same `android-device <serial> <adb> <scrcpy-server>`
+helper transport as physical Android, addressed only to the session's exact
+`emulator-<port>` serial. It bypasses workspace target resolution and device
+leases. The server rechecks the private home's created-device ledger, recorded
+serial and system image, the running AVD identity and ABI. Unknown state refuses
+capture and input. The helper uses the host SDK from `ANDROID_HOME`,
+`ANDROID_SDK_ROOT` or `$HOME/Library/Android/sdk`, including under the LaunchAgent.
+It pushes the built scrcpy jar to `/data/local/tmp` and removes both that jar
+and its adb forward when capture stops. One viewer pool serves each session;
+the lifetime claim tracks the helper as its child. Android capture requires no
+macOS screen-recording permission.
+
 Start control with `device-host.control.begin` and
 `{"session":"<hosted-session-id>"}`. Its result returns a connection-bound
 control session ID and `lease: null`: the hosted lifetime claim protects this
 private device. Only one controller can drive the device; `takeOver: true`
 replaces the previous controller. Use the returned control ID with
 `device-host.input.touch|text`, using the same parameters as ordinary input.
-iOS also supports `device-host.input.button|rotate|posture`. macOS also supports
+iOS also supports `device-host.input.button|rotate|posture`. Android supports
+`device-host.input.button` through scrcpy; rotation and posture are unavailable
+on this path, as for physical Android devices. macOS also supports
 `device-host.input.scroll|key`; these two methods are for macOS sessions only.
 Touch coordinates range from 0 to 1 on the streamed display.
 End it with `device-host.control.end` and `{"session":"<control-id>"}`.
@@ -847,8 +932,7 @@ Hosted posture commands hold a separate child-aware input claim. A surviving
 command or unresolved child identity blocks replacement ownership, install and
 stop even after the server and capture helper exit; the refusal names the claim
 and its manual cleanup command. An unknown or lost owner requires explicit stop
-before replacement. This worker
-protocol does not add CLI placement or a local viewer relay; those remain in
+before replacement. Automatic placement remains in
 [#2266](https://github.com/appandflow/stim/issues/2266).
 
 ## Run as a service
@@ -1177,11 +1261,11 @@ closes its connections and cancels its builds.
   another client, gets `bad-request`.
 - `build.artifact` takes the `job` of a successful build and sends the archive
   as binary frames, each 32 bytes of its sha256 and then the next bytes, then
-  answers `{ "name", "size", "sha256" }`, and deletes it here. For an iOS simulator or macOS
+  answers `{ "name", "size", "sha256" }`, and deletes it here. For an iOS simulator, Android emulator or macOS
   job the answer also carries `handoff`, a single-use token, and the staged
-  `.app` stays for 10 minutes so a hosted session on this Mac can take it with
+  `.app` or APK stays for 10 minutes so a hosted session on this Mac can take it with
   `device-host.app.handoff`. A client keeps at most one such bundle; its next
-  fetched iOS or macOS build or a revoked approval deletes it. An archive nobody fetched is deleted when its job
+  fetched native build or a revoked approval deletes it. An archive nobody fetched is deleted when its job
   is cancelled; one left by a server that crashed stays under
   `repos/<repo>/out/` until you delete it.
 
@@ -1472,6 +1556,16 @@ Events are `{ "event", "subscription", ... }`.
   `at` and `frames.seek` on it fail with `no-recording`, and it counts
   toward no idle check.
 
+- **Archive detail.** `archive.detail` takes `{ archive: archived[].id }` and needs
+  `read`. It returns `{ builds, recordings }`: the archive's own iOS and Android
+  build history in the live environment's `builds` shape, and every retained
+  recording slot as `{ platform, slot, spans }`. Spans use the same ranges as
+  `replay.range`; devices without spans are omitted. Missing or unreadable state
+  yields `builds: {}`, and no recordings yields `recordings: []`. Reads share the
+  archive request queue, refuse unknown archives with `unknown-workspace`, and
+  skip symlinks. Older servers refuse it with `unknown-method`.
+  `status` keeps only the archive's build summary.
+
 - **Replay.** `replay.range` takes exactly one of `workspace` or `archive`, plus `platform` and `slot`
   (`default` when absent), like `frames.subscribe`, and returns what can be
   replayed of that device slot's [recording](#recording):

package/dist/{protocol-BHSl7bQ_.mjs → protocol-wBQmYsnp.mjs}

@@ -187,13 +187,26 @@ function protocolJsonSchema() {
 									"deviceKey"
 								],
 								additionalProperties: false,
-								oneOf: [{
-									required: ["backend"],
-									properties: { deviceKey: { pattern: "^ios:mobile:[a-fA-F0-9-]{36}$" } }
-								}, {
-									not: { required: ["backend"] },
-									properties: { deviceKey: { pattern: "^[A-Za-z0-9_-]+(?:\\.[A-Za-z0-9_-]+)+@[1-9][0-9]{0,9}$" } }
-								}],
+								oneOf: [
+									{
+										required: ["backend"],
+										properties: {
+											backend: { const: "ios-instance" },
+											deviceKey: { pattern: "^ios:mobile:[a-fA-F0-9-]{36}$" }
+										}
+									},
+									{
+										required: ["backend"],
+										properties: {
+											backend: { const: "android-instance" },
+											deviceKey: { pattern: "^android:mobile:emulator-[0-9]+$" }
+										}
+									},
+									{
+										not: { required: ["backend"] },
+										properties: { deviceKey: { pattern: "^[A-Za-z0-9_-]+(?:\\.[A-Za-z0-9_-]+)+@[1-9][0-9]{0,9}$" } }
+									}
+								],
 								properties: {
 									tenant: {
 										type: "string",
@@ -207,7 +220,7 @@ function protocolJsonSchema() {
 										type: "string",
 										pattern: "^[A-Za-z0-9._-]{1,128}$"
 									},
-									backend: { const: "ios-instance" },
+									backend: { enum: ["ios-instance", "android-instance"] },
 									deviceKey: { type: "string" }
 								}
 							}
@@ -391,6 +404,19 @@ function protocolJsonSchema() {
 					}
 				}
 			},
+			HostedLocalDeviceCount: { anyOf: [{
+				type: "integer",
+				minimum: 0
+			}, {
+				type: "object",
+				required: ["unknown"],
+				additionalProperties: false,
+				properties: { unknown: {
+					type: "string",
+					minLength: 1,
+					maxLength: 4e3
+				} }
+			}] },
 			HostedDeviceOffer: {
 				type: "object",
 				required: [
@@ -444,7 +470,8 @@ function protocolJsonSchema() {
 							workerDiskFreeBytes: {
 								type: ["number", "null"],
 								minimum: 0
-							}
+							},
+							localDevices: { $ref: "#/$defs/HostedLocalDeviceCount" }
 						}
 					},
 					capacity: {
@@ -467,7 +494,8 @@ function protocolJsonSchema() {
 							available: {
 								type: ["integer", "null"],
 								minimum: 0
-							}
+							},
+							local: { $ref: "#/$defs/HostedLocalDeviceCount" }
 						}
 					}
 				},
@@ -541,6 +569,68 @@ function protocolJsonSchema() {
 					maximum: 65535
 				} }
 			},
+			HostedSessionRow: {
+				type: "object",
+				required: [
+					"id",
+					"client",
+					"platform",
+					"device",
+					"app",
+					"state",
+					"parked",
+					"since",
+					"workspace"
+				],
+				additionalProperties: false,
+				properties: {
+					id: { type: "string" },
+					client: {
+						type: "object",
+						required: ["id", "name"],
+						additionalProperties: false,
+						properties: {
+							id: { type: "string" },
+							name: { type: "string" }
+						}
+					},
+					platform: { enum: [
+						"ios",
+						"android",
+						"macos"
+					] },
+					device: { type: ["string", "null"] },
+					app: { type: ["string", "null"] },
+					state: { enum: [
+						"preparing",
+						"ready",
+						"stopping",
+						"stopped",
+						"unknown"
+					] },
+					parked: { type: "boolean" },
+					since: { type: "string" },
+					workspace: { type: "string" }
+				}
+			},
+			HostedSessionsResult: {
+				type: "object",
+				required: ["sessions"],
+				additionalProperties: false,
+				properties: { sessions: {
+					type: "array",
+					items: { $ref: "#/$defs/HostedSessionRow" }
+				} }
+			},
+			HostedSessionStopResult: {
+				type: "object",
+				required: ["id", "state"],
+				additionalProperties: false,
+				properties: {
+					id: { type: "string" },
+					state: { enum: ["stopping", "stopped"] }
+				}
+			},
 			HostedDeviceSession: {
 				type: "object",
 				required: [
@@ -662,6 +752,7 @@ function protocolJsonSchema() {
 					createdAt: { type: "string" },
 					notice: { type: "string" },
 					appAttempt: { type: "string" },
+					agent: { $ref: "#/$defs/HostedAppDelivery/properties/agent" },
 					metroPort: {
 						type: "integer",
 						minimum: 1,
@@ -1689,6 +1780,11 @@ function protocolJsonSchema() {
 						minimum: 1,
 						maximum: 65535
 					},
+					clientMetroPort: {
+						type: "integer",
+						minimum: 1,
+						maximum: 65535
+					},
 					secret: {
 						type: "string",
 						pattern: "^[a-f0-9]{64}$"
@@ -1865,6 +1961,16 @@ function protocolJsonSchema() {
 						}
 					}
 				}),
+				request("archive.detail", {
+					type: "object",
+					required: ["archive"],
+					additionalProperties: false,
+					properties: { archive: {
+						type: "string",
+						minLength: 1,
+						pattern: "^(?!.*\\.\\.)[^/\\\\\\u0000]+$"
+					} }
+				}),
 				request("replay.keyframe", {
 					type: "object",
 					required: ["platform", "at"],
@@ -2263,6 +2369,8 @@ function protocolJsonSchema() {
 				request("build.artifact", buildJob),
 				request("build.attach", buildJob),
 				request("server.update.status"),
+				request("device-host.sessions"),
+				request("device-host.sessions.stop", session({})),
 				request("machines.update.start", {
 					type: "object",
 					required: ["machine"],
@@ -2352,6 +2460,8 @@ function protocolJsonSchema() {
 					result: { anyOf: [
 						{ $ref: "#/$defs/HostedDeviceOffer" },
 						{ $ref: "#/$defs/HostedDeviceSession" },
+						{ $ref: "#/$defs/HostedSessionsResult" },
+						{ $ref: "#/$defs/HostedSessionStopResult" },
 						{ $ref: "#/$defs/HostedAppDelivery" },
 						{ $ref: "#/$defs/HostedMetroResult" },
 						{ $ref: "#/$defs/HostedAppOfferResult" },

package/dist/protocol.mjs

@@ -1,3 +1,3 @@
-import { t as protocolJsonSchema } from "./protocol-BHSl7bQ_.mjs";
+import { t as protocolJsonSchema } from "./protocol-wBQmYsnp.mjs";
 export * from "@stim-cli/core/protocol";
 export { protocolJsonSchema };