feat(agentos): dashboard inspector redesign

crates/agentos-actor-plugin/src/actions/contract_surface.rs

@@ -250,10 +250,45 @@ pub const ACTION_CONTRACTS: &[ActionContract] = &[
         reply_shape: ReplyShape::Array,
         ts_signature: "listSoftware: (c: Ctx) => Promise<SoftwareInfo[]>;",
     },
+    // Observe-only actions (`actions::OBSERVE_ONLY`): dispatched without
+    // booting a sleeping VM. See `dispatch_observe` in actions/mod.rs.
+    ActionContract {
+        name: "getRuntimeHealth",
+        reply_shape: ReplyShape::Object(&[
+            "agentExits",
+            "booted",
+            "sessions",
+            "sidecar",
+            "stderrTail",
+            "warnings",
+        ]),
+        ts_signature: "getRuntimeHealth: (c: Ctx) => Promise<RuntimeHealth>;",
+    },
+    ActionContract {
+        name: "listSessions",
+        reply_shape: ReplyShape::Array,
+        ts_signature: "listSessions: (c: Ctx) => Promise<LiveSessionInfo[]>;",
+    },
+    ActionContract {
+        name: "cancelPrompt",
+        reply_shape: ReplyShape::Unit,
+        ts_signature: "cancelPrompt: (c: Ctx, sessionId: string) => Promise<void>;",
+    },
+    ActionContract {
+        name: "listPendingPermissions",
+        reply_shape: ReplyShape::Array,
+        ts_signature:
+            "listPendingPermissions: (c: Ctx) => Promise<PendingPermissionInfo[]>;",
+    },
 ];
 
 #[allow(dead_code)]
 pub const EVENT_CONTRACTS: &[EventContract] = &[
+    EventContract {
+        name: "fsChanged",
+        payload_shape: ReplyShape::Object(&["dirs", "overflow"]),
+        ts_signature: "fsChanged: FsChangedPayload;",
+    },
     EventContract {
         name: "sessionEvent",
         payload_shape: ReplyShape::Object(&["event", "sessionId"]),
@@ -264,6 +299,11 @@ pub const EVENT_CONTRACTS: &[EventContract] = &[
         payload_shape: ReplyShape::Object(&["request", "sessionId"]),
         ts_signature: "permissionRequest: PermissionRequestPayload;",
     },
+    EventContract {
+        name: "permissionResolved",
+        payload_shape: ReplyShape::Object(&["permissionId", "reply", "sessionId"]),
+        ts_signature: "permissionResolved: PermissionResolvedPayload;",
+    },
     EventContract {
         name: "agentCrashed",
         payload_shape: ReplyShape::Object(&["event", "sessionId"]),
@@ -511,6 +551,61 @@ const DTO_INTERFACES: &[TsInterface] = &[
             field("commands", "string[]"),
         ],
     },
+    TsInterface {
+        name: "LiveSessionInfo",
+        fields: &[field("sessionId", "string"), field("agentType", "string")],
+    },
+    TsInterface {
+        name: "PendingPermissionInfo",
+        fields: &[
+            field("sessionId", "string"),
+            field("permissionId", "string"),
+            optional_field("description", "string"),
+            field("params", "Record<string, unknown>"),
+            field("requestedAt", "number"),
+        ],
+    },
+    TsInterface {
+        name: "RuntimeLimitWarning",
+        fields: &[
+            field("ts", "number"),
+            field("limit", "string"),
+            field("category", "string"),
+            field("observed", "number"),
+            field("capacity", "number"),
+            field("fillPercent", "number"),
+        ],
+    },
+    TsInterface {
+        name: "RuntimeAgentExit",
+        fields: &[
+            field("ts", "number"),
+            field("sessionId", "string"),
+            field("agentType", "string"),
+            field("exitCode", "number | null"),
+            field("restart", "string"),
+            field("restartCount", "number"),
+        ],
+    },
+    TsInterface {
+        name: "RuntimeStderrLine",
+        fields: &[field("ts", "number"), field("line", "string")],
+    },
+    TsInterface {
+        name: "RuntimeSidecarInfo",
+        fields: &[field("state", "string"), field("activeVmCount", "number")],
+    },
+    TsInterface {
+        name: "RuntimeHealth",
+        fields: &[
+            field("booted", "boolean"),
+            field("sessions", "number | null"),
+            field("sidecar", "RuntimeSidecarInfo | null"),
+            field("warnings", "RuntimeLimitWarning[]"),
+            field("agentExits", "RuntimeAgentExit[]"),
+            field("stderrTail", "RuntimeStderrLine[]"),
+        ],
+    },
 ];
 
 const fn field(name: &'static str, ty: &'static str) -> TsField {

crates/agentos-actor-plugin/src/actions/filesystem.rs

@@ -264,3 +264,45 @@ impl From<BatchReadResult> for BatchReadResultDto {
         }
     }
 }
+
+/// `fsChanged` broadcast payload: one coalesced guest filesystem change
+/// window from the runtime's `filesystem.changed` events.
+#[derive(Serialize)]
+struct FsChangedEvent {
+    dirs: Vec<String>,
+    overflow: bool,
+}
+
+pub(crate) fn encode_fs_changed_event(dirs: Vec<String>, overflow: bool) -> Result<Vec<u8>> {
+    super::encode_event_arg(&FsChangedEvent { dirs, overflow })
+}
+
+/// One `fsChanged` pump per VM lifetime, spawned on fresh boot next to the
+/// health pumps: fans the client's coalesced `on_fs_changed` stream out to
+/// actor clients as `fsChanged` broadcasts (the inspector Filesystem tab's
+/// realtime invalidation signal). Tracked in [`Vars::fs_change_task`] so VM
+/// teardown aborts it; a lagged subscriber already degrades to
+/// `overflow: true` inside the client stream, so nothing is lost silently.
+pub(crate) fn spawn_fs_change_pump(host: &crate::host_ctx::HostCtx, vm: &AgentOs, vars: &mut super::Vars) {
+    use futures::StreamExt;
+
+    let (mut stream, subscription) = vm.on_fs_changed();
+    let host = host.clone();
+    vars.fs_change_task = Some(tokio::spawn(async move {
+        // RAII guard: dropping the stream on abort is the unsubscribe.
+        let _subscription = subscription;
+        while let Some(change) = stream.next().await {
+            match encode_fs_changed_event(change.dirs, change.overflow) {
+                Ok(bytes) => {
+                    let status = host.broadcast(b"fsChanged".to_vec(), bytes);
+                    if status != rivet_actor_plugin_abi::AbiStatus::Ok {
+                        tracing::warn!(?status, "fsChanged broadcast failed");
+                    }
+                }
+                Err(error) => {
+                    tracing::warn!(?error, "failed to encode fsChanged broadcast");
+                }
+            }
+        }
+    }));
+}