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

7 files changed, 188 insertions, 16 deletions

diff --git a/SKILL.md b/SKILL.md
index be72d022..1cf0a795 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -165,7 +165,7 @@ press Enter or other keys:
 herdr pane send-keys 1-1 Enter
 ```
 
-`pane run` appends a trailing carriage return (`\r`) to the text so the command executes:
+`pane run` sends the text and then a real `Enter` key in one request:
 
 ```bash
 herdr pane run 1-1 "echo hello"
diff --git a/SOCKET_API.md b/SOCKET_API.md
index ad5a80e7..3329e0b4 100644
--- a/SOCKET_API.md
+++ b/SOCKET_API.md
@@ -186,6 +186,7 @@ agent states are:
 | `pane.split` | split a pane and create a sibling pane | `pane_info` |
 | `pane.send_text` | send literal text without Enter | `ok` |
 | `pane.send_keys` | send keypresses like `Enter` | `ok` |
+| `pane.send_input` | send literal text plus keypresses in order | `ok` |
 | `pane.close` | close a pane | `ok` |
 | `pane.wait_for_output` | one-shot blocking wait for text | `output_matched` |
 | `events.subscribe` | start a long-lived subscription stream | `subscription_started` ack |
@@ -533,6 +534,22 @@ params:
 
 use this after `pane.send_text` when you want to submit a command.
 
+### `pane.send_input`
+
+params:
+
+```json
+{
+  "pane_id": "1-1",
+  "text": "bun run dev",
+  "keys": ["Enter"]
+}
+```
+
+this sends text plus encoded keypresses in order within one request. when bracketed paste is enabled in the pane, the text portion is sent as a paste payload before the keys. use this when you need `text + Enter` to behave more like a real keypress sequence than `pane.send_text` with a literal trailing `\r`.
+
+`text` and `keys` are both optional, but at least one should usually be present.
+
 ### `pane.close`
 
 params:
@@ -830,7 +847,7 @@ herdr wait agent-state <pane_id> --state <idle|working|blocked|unknown> [--timeo
 - `pane read --source recent-unwrapped` returns recent terminal text with soft wraps joined back together
 - `pane send-text`, `pane send-keys`, and `pane run` print nothing on success
 - list/get/create/split/wait commands print json on success
-- `pane run` is a convenience wrapper for `pane send-text` with a trailing carriage return (`\r`)
+- `pane run` is a convenience wrapper for `pane.send_input` with the command text followed by a real `Enter` keypress
 - `wait agent-state` is a cli convenience built on top of event subscriptions
 - `--raw` disables ansi stripping for `pane read` and `wait output`
 - `wait output --source recent` matches against unwrapped recent terminal text by default, so pane width and soft wrapping do not break matches
@@ -860,7 +877,7 @@ herdr pane read 1-1 --source recent --lines 80
 
 ## behavior notes and gotchas
 
-- `pane.send_text` sends literal text only. if you want to execute a command, follow it with `pane.send_keys` and `Enter`, or use cli `pane run`, which appends a trailing carriage return (`\r`).
+- `pane.send_text` sends literal text only. if you want to execute a command, follow it with `pane.send_keys` and `Enter`, use `pane.send_input` for ordered `text + keypress` input, or use cli `pane run`, which sends the text and then a real Enter key in one request.
 - `pane.read` and `pane.wait_for_output` strip ansi by default.
 - `pane.output_matched` subscriptions fire on transitions into a matching state; they do not repeatedly spam the same still-visible match on every poll.
 - closing the socket connection ends the subscription.
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> {
diff --git a/tests/api_ping.rs b/tests/api_ping.rs
index 84129752..9a7e3267 100644
--- a/tests/api_ping.rs
+++ b/tests/api_ping.rs
@@ -336,6 +336,28 @@ fn workspace_list_and_create_round_trip() {
         .unwrap()
         .contains("gamma"));
 
+    let send_input = send_request(
+        &socket_path,
+        &format!(
+            r#"{{"id":"req_12b","method":"pane.send_input","params":{{"pane_id":"{}","text":"echo delta","keys":["Enter"]}}}}"#,
+            pane_id
+        ),
+    );
+    assert_eq!(send_input["result"]["type"], "ok");
+
+    let waited_delta = send_request(
+        &socket_path,
+        &format!(
+            r#"{{"id":"req_12c","method":"pane.wait_for_output","params":{{"pane_id":"{}","source":"recent","lines":40,"match":{{"type":"substring","value":"delta"}},"timeout_ms":2000}}}}"#,
+            pane_id
+        ),
+    );
+    assert_eq!(waited_delta["result"]["type"], "output_matched");
+    assert!(waited_delta["result"]["matched_line"]
+        .as_str()
+        .unwrap()
+        .contains("delta"));
+
     let waited_regex = send_request(
         &socket_path,
         &format!(
diff --git a/tests/cli_wrapper.rs b/tests/cli_wrapper.rs
index 97d309a4..3e9b9f31 100644
--- a/tests/cli_wrapper.rs
+++ b/tests/cli_wrapper.rs
@@ -126,7 +126,7 @@ fn send_request(socket_path: &Path, json: &str) -> serde_json::Value {
 }
 
 #[test]
-fn pane_run_sends_one_send_text_request_with_trailing_carriage_return() {
+fn pane_run_sends_one_send_input_request_with_enter_key() {
     let base = unique_test_dir();
     fs::create_dir_all(&base).unwrap();
     let socket_path = base.join("herdr.sock");
@@ -179,9 +179,13 @@ fn pane_run_sends_one_send_text_request_with_trailing_carriage_return() {
 
     let (first_line, second_line) = server.join().unwrap();
     let first_request: serde_json::Value = serde_json::from_str(&first_line).unwrap();
-    assert_eq!(first_request["method"], "pane.send_text");
+    assert_eq!(first_request["method"], "pane.send_input");
     assert_eq!(first_request["params"]["pane_id"], "1-1");
-    assert_eq!(first_request["params"]["text"], "echo hello\r");
+    assert_eq!(first_request["params"]["text"], "echo hello");
+    assert_eq!(
+        first_request["params"]["keys"],
+        serde_json::json!(["Enter"])
+    );
     assert!(
         second_line.is_none(),
         "pane run sent an unexpected second request: {:?}",