1 files changed, 75 insertions, 15 deletions
diff --git a/src/cli.rs b/src/cli.rs
index 70420b09..2f9ef0d7 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -4,8 +4,10 @@ use serde::Serialize;
 
 use crate::api::client::{ApiClient, ApiClientError};
 use crate::api::schema::{
-    AgentStatus, ClientWindowTitleSetParams, EmptyParams, Method, OutputMatch, PaneAgentState,
-    PaneWaitForOutputParams, ReadFormat, ReadSource, Request, SplitDirection, Subscription,
+    AgentStatus, ClientWindowTitleSetParams, EmptyParams, EventData, EventMatch, EventsWaitParams,
+    Method, OutputMatch, PaneAgentState, PaneWaitForOutputParams, ReadFormat, ReadSource, Request,
+    ResponseResult, SplitDirection, SubscriptionEventData, SubscriptionEventEnvelope,
+    SubscriptionEventKind,
 };
 
 mod agent;
@@ -820,19 +822,77 @@ fn wait_agent_status(args: &[String]) -> std::io::Result<i32> {
         return Ok(2);
     };
 
-    wait_for_agent_change(
-        Request {
-            id: "cli:wait:agent-status".into(),
-            method: Method::EventsSubscribe(crate::api::schema::EventsSubscribeParams {
-                subscriptions: vec![Subscription::PaneAgentStatusChanged {
-                    pane_id,
-                    agent_status: Some(agent_status),
-                }],
-            }),
-        },
-        timeout_ms,
-        "timed out waiting for agent status change",
-    )
+    wait_for_agent_status_change(pane_id, agent_status, timeout_ms)
+}
+
+fn wait_for_agent_status_change(
+    pane_id: String,
+    agent_status: AgentStatus,
+    timeout_ms: Option<u64>,
+) -> std::io::Result<i32> {
+    let request = Request {
+        id: "cli:wait:agent-status".into(),
+        method: Method::EventsWait(EventsWaitParams {
+            match_event: EventMatch::PaneAgentStatusChanged {
+                pane_id,
+                agent_status,
+            },
+            timeout_ms,
+        }),
+    };
+    let response = send_request(&request)?;
+    match crate::api::client::parse_response_value(response) {
+        Ok(success) => {
+            let ResponseResult::WaitMatched { event } = success.result else {
+                return Err(std::io::Error::other("unexpected wait response result"));
+            };
+            let EventData::PaneAgentStatusChanged {
+                pane_id,
+                workspace_id,
+                agent_status,
+                agent,
+                title,
+                display_agent,
+                custom_status,
+                state_labels,
+            } = event.data
+            else {
+                return Err(std::io::Error::other("unexpected wait event data"));
+            };
+            let event = SubscriptionEventEnvelope {
+                event: SubscriptionEventKind::PaneAgentStatusChanged,
+                data: SubscriptionEventData::PaneAgentStatusChanged(
+                    crate::api::schema::PaneAgentStatusChangedEvent {
+                        pane_id,
+                        workspace_id,
+                        agent_status,
+                        agent,
+                        custom_status,
+                        title,
+                        display_agent,
+                        state_labels,
+                    },
+                ),
+            };
+            println!(
+                "{}",
+                serde_json::to_string(&event).map_err(std::io::Error::other)?
+            );
+            Ok(0)
+        }
+        Err(ApiClientError::ErrorResponse(response)) => {
+            if response.error.code == "timeout" {
+                eprintln!("timed out waiting for agent status change");
+            } else {
+                eprintln!(
+                    "{}",
+                    serde_json::to_string(&response).map_err(std::io::Error::other)?
+                );
+            }
+            Ok(1)
+        }
+        Err(err) => Err(api_client_error_to_io(err)),
+    }
 }
 
 pub(super) fn wait_for_agent_change(