refactor: separate server client boundaries

1 files changed, 127 insertions, 0 deletions

diff --git a/src/app/api/agents.rs b/src/app/api/agents.rs
new file mode 100644
index 00000000..4077b38c
--- /dev/null
+++ b/src/app/api/agents.rs
@@ -0,0 +1,127 @@
+use bytes::Bytes;
+
+use crate::api::schema::{
+    AgentRenameParams, AgentSendParams, AgentStartParams, AgentTarget, PaneReadResult, ReadFormat,
+    ReadSource, ResponseResult,
+};
+use crate::app::App;
+
+use super::responses::{encode_error, encode_error_body, encode_success};
+
+impl App {
+    pub(super) fn handle_agent_list(&mut self, id: String) -> String {
+        encode_success(
+            id,
+            ResponseResult::AgentList {
+                agents: self.collect_agent_infos(),
+            },
+        )
+    }
+
+    pub(super) fn handle_agent_get(&mut self, id: String, target: AgentTarget) -> String {
+        let agent = match self.agent_info_for_target(&target.target) {
+            Ok(agent) => agent,
+            Err(err) => return encode_error_body(id, self.agent_target_error_body(err)),
+        };
+
+        encode_success(id, ResponseResult::AgentInfo { agent })
+    }
+
+    pub(super) fn handle_agent_focus(&mut self, id: String, target: AgentTarget) -> String {
+        let agent = match self.focus_agent_target(&target.target) {
+            Ok(agent) => agent,
+            Err(err) => return encode_error_body(id, self.agent_target_error_body(err)),
+        };
+
+        encode_success(id, ResponseResult::AgentInfo { agent })
+    }
+
+    pub(super) fn handle_agent_rename(&mut self, id: String, params: AgentRenameParams) -> String {
+        let agent = match self.rename_agent_target(&params.target, params.name) {
+            Ok(agent) => agent,
+            Err(err) => return encode_error_body(id, self.agent_rename_error_body(err)),
+        };
+
+        encode_success(id, ResponseResult::AgentInfo { agent })
+    }
+
+    pub(super) fn handle_agent_start(&mut self, id: String, params: AgentStartParams) -> String {
+        let (agent, argv) = match self.start_agent(params) {
+            Ok(started) => started,
+            Err(err) => return encode_error_body(id, self.agent_start_error_body(err)),
+        };
+
+        encode_success(id, ResponseResult::AgentStarted { agent, argv })
+    }
+
+    pub(super) fn handle_agent_read(
+        &mut self,
+        id: String,
+        params: crate::api::schema::AgentReadParams,
+    ) -> String {
+        let resolved = match self.resolve_terminal_target(&params.target) {
+            Ok(resolved) => resolved,
+            Err(err) => return encode_error_body(id, self.agent_target_error_body(err)),
+        };
+        let Some((pane, workspace_id)) = self.lookup_runtime(resolved.ws_idx, resolved.pane_id)
+        else {
+            return agent_not_found(id, &params.target);
+        };
+        let requested_lines = params.lines.unwrap_or(80).min(1000) as usize;
+        let text = match params.format {
+            ReadFormat::Text => match params.source {
+                ReadSource::Visible => pane.visible_text(),
+                ReadSource::Recent => pane.recent_text(requested_lines),
+                ReadSource::RecentUnwrapped => pane.recent_unwrapped_text(requested_lines),
+            },
+            ReadFormat::Ansi => match params.source {
+                ReadSource::Visible => pane.visible_ansi(),
+                ReadSource::Recent => pane.recent_ansi(requested_lines),
+                ReadSource::RecentUnwrapped => pane.recent_unwrapped_ansi(requested_lines),
+            },
+        };
+
+        encode_success(
+            id,
+            ResponseResult::PaneRead {
+                read: PaneReadResult {
+                    pane_id: self
+                        .public_pane_id(resolved.ws_idx, resolved.pane_id)
+                        .unwrap_or_else(|| params.target.clone()),
+                    workspace_id,
+                    tab_id: self
+                        .public_tab_id(resolved.ws_idx, resolved.tab_idx)
+                        .unwrap(),
+                    source: params.source,
+                    format: params.format,
+                    text,
+                    revision: 0,
+                    truncated: false,
+                },
+            },
+        )
+    }
+
+    pub(super) fn handle_agent_send(&mut self, id: String, params: AgentSendParams) -> String {
+        let resolved = match self.resolve_terminal_target(&params.target) {
+            Ok(resolved) => resolved,
+            Err(err) => return encode_error_body(id, self.agent_target_error_body(err)),
+        };
+        let Some(runtime) = self.lookup_runtime_sender(resolved.ws_idx, resolved.pane_id) else {
+            return agent_not_found(id, &params.target);
+        };
+        if let Err(err) = runtime.try_send_bytes(Bytes::from(params.text)) {
+            return encode_error(id, "agent_send_failed", err.to_string());
+        }
+
+        encode_success(id, ResponseResult::Ok {})
+    }
+}
+
+fn agent_not_found(id: String, target: &str) -> String {
+    encode_error(
+        id,
+        "agent_not_found",
+        format!("agent target {target} not found"),
+    )
+}