fix: make pane run use bracketed-paste-aware send input

3 files changed, 139 insertions, 10 deletions

diff --git a/src/api/schema.rs b/src/api/schema.rs
index e266f0ff..063663fa 100644
--- a/src/api/schema.rs
+++ b/src/api/schema.rs
@@ -46,6 +46,8 @@ pub enum Method {
     PaneSendText(PaneSendTextParams),
     #[serde(rename = "pane.send_keys")]
     PaneSendKeys(PaneSendKeysParams),
+    #[serde(rename = "pane.send_input")]
+    PaneSendInput(PaneSendInputParams),
     #[serde(rename = "pane.read")]
     PaneRead(PaneReadParams),
     #[serde(rename = "pane.report_agent")]
@@ -159,6 +161,15 @@ pub struct PaneSendKeysParams {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PaneSendInputParams {
+    pub pane_id: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub text: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub keys: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct PaneReadParams {
     pub pane_id: String,
     pub source: ReadSource,
@@ -693,6 +704,27 @@ mod tests {
     }
 
     #[test]
+    fn pane_send_input_defaults_to_empty_text_and_keys() {
+        let json = r#"
+        {
+            "id": "req_1",
+            "method": "pane.send_input",
+            "params": {
+                "pane_id": "p_1"
+            }
+        }
+        "#;
+
+        let request: Request = serde_json::from_str(json).unwrap();
+        let Method::PaneSendInput(params) = request.method else {
+            panic!("wrong method parsed");
+        };
+        assert_eq!(params.pane_id, "p_1");
+        assert!(params.text.is_empty());
+        assert!(params.keys.is_empty());
+    }
+
+    #[test]
     fn pane_wait_for_output_defaults_strip_ansi_to_true() {
         let json = r#"
         {
diff --git a/src/app/mod.rs b/src/app/mod.rs
index 870a485b..344a1a66 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -1711,6 +1711,70 @@ impl App {
                     result: ResponseResult::Ok {},
                 }
             }
+            Method::PaneSendInput(params) => {
+                let Some((ws_idx, pane_id)) = self.parse_pane_id(&params.pane_id) else {
+                    return serde_json::to_string(&ErrorResponse {
+                        id: request.id,
+                        error: ErrorBody {
+                            code: "pane_not_found".into(),
+                            message: format!("pane {} not found", params.pane_id),
+                        },
+                    })
+                    .unwrap();
+                };
+                let Some(runtime) = self.lookup_runtime_sender(ws_idx, pane_id) else {
+                    return serde_json::to_string(&ErrorResponse {
+                        id: request.id,
+                        error: ErrorBody {
+                            code: "pane_not_found".into(),
+                            message: format!("pane {} not found", params.pane_id),
+                        },
+                    })
+                    .unwrap();
+                };
+                let encoded_keys = match encode_api_keys(runtime, &params.keys) {
+                    Ok(encoded_keys) => encoded_keys,
+                    Err(key) => {
+                        return serde_json::to_string(&ErrorResponse {
+                            id: request.id,
+                            error: ErrorBody {
+                                code: "invalid_key".into(),
+                                message: format!("unsupported key {key}"),
+                            },
+                        })
+                        .unwrap();
+                    }
+                };
+                if !params.text.is_empty() {
+                    let text_bytes = encode_api_text(runtime, &params.text);
+                    if let Err(err) = runtime.try_send_bytes(Bytes::from(text_bytes)) {
+                        return serde_json::to_string(&ErrorResponse {
+                            id: request.id,
+                            error: ErrorBody {
+                                code: "pane_send_failed".into(),
+                                message: err.to_string(),
+                            },
+                        })
+                        .unwrap();
+                    }
+                }
+                for bytes in encoded_keys {
+                    if let Err(err) = runtime.try_send_bytes(Bytes::from(bytes)) {
+                        return serde_json::to_string(&ErrorResponse {
+                            id: request.id,
+                            error: ErrorBody {
+                                code: "pane_send_failed".into(),
+                                message: err.to_string(),
+                            },
+                        })
+                        .unwrap();
+                    }
+                }
+                SuccessResponse {
+                    id: request.id,
+                    result: ResponseResult::Ok {},
+                }
+            }
             Method::PaneClose(target) => {
                 let Some((ws_idx, pane_id)) = self.parse_pane_id(&target.pane_id) else {
                     return serde_json::to_string(&ErrorResponse {
@@ -1784,18 +1848,20 @@ impl App {
                     })
                     .unwrap();
                 };
-                for key in params.keys {
-                    let Some(key_event) = parse_api_key(&key) else {
+                let encoded_keys = match encode_api_keys(runtime, &params.keys) {
+                    Ok(encoded_keys) => encoded_keys,
+                    Err(key) => {
                         return serde_json::to_string(&ErrorResponse {
                             id: request.id,
                             error: ErrorBody {
                                 code: "invalid_key".into(),
-                                message: format!("unsupported key {}", key),
+                                message: format!("unsupported key {key}"),
                             },
                         })
                         .unwrap();
-                    };
-                    let bytes = runtime.encode_terminal_key(key_event.into());
+                    }
+                };
+                for bytes in encoded_keys {
                     if let Err(err) = runtime.try_send_bytes(Bytes::from(bytes)) {
                         return serde_json::to_string(&ErrorResponse {
                             id: request.id,
@@ -2194,6 +2260,32 @@ fn parse_api_key(key: &str) -> Option<crossterm::event::KeyEvent> {
     }
 }
 
+fn encode_api_text(runtime: &crate::pane::PaneRuntime, text: &str) -> Vec<u8> {
+    let bracketed = runtime
+        .input_state()
+        .map(|state| state.bracketed_paste)
+        .unwrap_or(false);
+    if bracketed {
+        format!("\x1b[200~{text}\x1b[201~").into_bytes()
+    } else {
+        text.as_bytes().to_vec()
+    }
+}
+
+fn encode_api_keys(
+    runtime: &crate::pane::PaneRuntime,
+    keys: &[String],
+) -> Result<Vec<Vec<u8>>, String> {
+    let mut encoded_keys = Vec::with_capacity(keys.len());
+    for key in keys {
+        let Some(key_event) = parse_api_key(key) else {
+            return Err(key.clone());
+        };
+        encoded_keys.push(runtime.encode_terminal_key(key_event.into()));
+    }
+    Ok(encoded_keys)
+}
+
 fn detect_state_from_api(state: crate::api::schema::PaneAgentState) -> crate::detect::AgentState {
     match state {
         crate::api::schema::PaneAgentState::Idle => crate::detect::AgentState::Idle,
diff --git a/src/cli.rs b/src/cli.rs
index e5399eca..88ca5abd 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -7,9 +7,10 @@ use serde::Serialize;
 use crate::api;
 use crate::api::schema::{
     EmptyParams, Method, OutputMatch, PaneAgentState, PaneListParams, PaneReadParams,
-    PaneSendKeysParams, PaneSendTextParams, PaneSplitParams, PaneTarget, PaneWaitForOutputParams,
-    ReadSource, Request, SplitDirection, Subscription, TabCreateParams, TabListParams,
-    TabRenameParams, TabTarget, WorkspaceCreateParams, WorkspaceRenameParams, WorkspaceTarget,
+    PaneSendInputParams, PaneSendKeysParams, PaneSendTextParams, PaneSplitParams, PaneTarget,
+    PaneWaitForOutputParams, ReadSource, Request, SplitDirection, Subscription, TabCreateParams,
+    TabListParams, TabRenameParams, TabTarget, WorkspaceCreateParams, WorkspaceRenameParams,
+    WorkspaceTarget,
 };
 
 pub enum CommandOutcome {
@@ -596,8 +597,12 @@ fn pane_run(args: &[String]) -> std::io::Result<i32> {
     }
 
     let pane_id = normalize_pane_id(&args[0]);
-    let text = format!("{}\r", args[1..].join(" "));
-    send_ok_request(Method::PaneSendText(PaneSendTextParams { pane_id, text }))
+    let text = args[1..].join(" ");
+    send_ok_request(Method::PaneSendInput(PaneSendInputParams {
+        pane_id,
+        text,
+        keys: vec!["Enter".into()],
+    }))
 }
 
 fn integration_install(args: &[String]) -> std::io::Result<i32> {