feat: add possibility to input in terminal windows

kosz78 · kosz78 · commit a3bdf83458af · 2025-05-28T20:11:44.000+07:00
diff --git a/src/agent/event.rs b/src/agent/event.rs
@@ -67,6 +67,8 @@ pub enum AgentOutputEvent {
 #[derive(Clone, Debug)]
 pub enum AgentControlEvent {
     SendMessage(String),
+    /// Sends data to stdin of running terminal by idx
+    TerminalData(usize, Vec<u8>),
     CancelTask,
     NewTask,
 }
diff --git a/src/agent/mod.rs b/src/agent/mod.rs
@@ -655,6 +655,9 @@ impl Agent {
                         self.sender.send(AgentOutputEvent::NewTask).ok();
                         persist_history(&self.messages);
                     }
+                    AgentControlEvent::TerminalData(idx, data) => {
+                        self.process_registry.read().await.send_data(idx, data);
+                    }
                 }
             }
             if let Err(e) = self.process_messages(system_prompt_token_count).await {
diff --git a/src/agent/utils.rs b/src/agent/utils.rs
@@ -106,11 +106,7 @@ pub async fn add_env_message<'a>(
                     "| {}    | {}                 | `{}` |",
                     id,
                     if let Some(exit_status) = status {
-                        if let Some(code) = exit_status.code() {
-                            format!("Exited({})", code)
-                        } else {
-                            "Exited(-1)".to_string()
-                        }
+                        format!("Exited({})", exit_status)
                     } else {
                         "Running".to_string()
                     },
diff --git a/src/tools/execute_command/mod.rs b/src/tools/execute_command/mod.rs
@@ -5,8 +5,8 @@ use std::process::ExitStatus;
 
 use anyhow::Result;
 use process_wrap::tokio::{TokioChildWrapper, TokioCommandWrap};
-use tokio::io::{AsyncBufReadExt, BufReader};
-use tokio::process::{ChildStderr, ChildStdout};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{ChildStderr, ChildStdin, ChildStdout};
 use tokio::sync::{mpsc, oneshot};
 
 use crate::agent::event::AgentCommandStatus;
@@ -27,22 +27,25 @@ pub struct ProcessRegistry {
 struct ProcessData {
     command: String,
     output: String,
-    exit_status: Option<ExitStatus>,
+    exit_status: Option<i32>,
     receiver: mpsc::UnboundedReceiver<ProcessOutput>,
     terminate_sender: Option<oneshot::Sender<()>>,
+    input_sender: Option<mpsc::UnboundedSender<Vec<u8>>>,
 }
 
 enum ProcessOutput {
-    Exited(ExitStatus),
+    Exited(Option<ExitStatus>),
     Output(String),
     Error(String),
 }
 
 struct ProcessRuntime {
     _process: Box<dyn TokioChildWrapper>,
     stdout: ChildStdout,
+    stdin: ChildStdin,
     stderr: ChildStderr,
     sender: mpsc::UnboundedSender<ProcessOutput>,
+    input_signal: mpsc::UnboundedReceiver<Vec<u8>>,
     terminate_signal: oneshot::Receiver<()>,
 }
 
@@ -52,29 +55,37 @@ impl ProcessRuntime {
 
         let stdout = Self::handle_stdout(self.stdout, self.sender.clone());
         let stderr = Self::handle_stderr(self.stderr, self.sender.clone());
+        let stdin = Self::handle_stdin(self.stdin, self.input_signal);
+
         let status = Box::into_pin(self._process.wait());
         pin!(stdout);
         pin!(stderr);
-        let mut exit_status = ExitStatus::default();
+        pin!(stdin);
+
+        let mut exit_status = None;
         tokio::select! {
             result = &mut stdout => {
                 tracing::trace!("Stdout handler completed: {:?}", result);
+                exit_status = Some(ExitStatus::default());
             }
             result = &mut stderr => {
                 tracing::trace!("Stderr handler completed: {:?}", result);
             }
             // capture the status so we don't need to wait for a timeout
             result = status => {
                 if let Ok(result) = result {
-                    exit_status = result;
+                    exit_status = Some(result);
                 }
                 tracing::trace!("Process exited with status: {:?}", result);
             }
+            result = &mut stdin => {
+                tracing::trace!("Stdin handler completed: {:?}", result);
+            }
             _ = self.terminate_signal => {
                 tracing::debug!("Receive terminal_signal");
                 if self._process.start_kill().is_ok() {
                     if let Ok(status) = Box::into_pin(self._process.wait()).await {
-                        exit_status = status;
+                        exit_status = Some(status);
                     }
                 }
             }
@@ -123,17 +134,36 @@ impl ProcessRuntime {
             }
         }
     }
+
+    async fn handle_stdin(mut stdin: ChildStdin, mut receiver: mpsc::UnboundedReceiver<Vec<u8>>) {
+        while let Some(data) = receiver.recv().await {
+            tracing::trace!("Writing data to stdin: {:?}", data);
+            if let Err(e) = stdin.write_all(data.as_slice()).await {
+                tracing::error!(error = ?e, "Error writing data to child process");
+                break;
+            }
+            if let Err(e) = stdin.flush().await {
+                tracing::error!(error = ?e, "Error flushing data to child process");
+                break;
+            }
+        }
+    }
 }
 
 impl ProcessRegistry {
     async fn spawn_process(
         &self,
         command: &str,
         cwd: &str,
-    ) -> Result<(Box<dyn TokioChildWrapper>, ChildStdout, ChildStderr)> {
+    ) -> Result<(
+        Box<dyn TokioChildWrapper>,
+        ChildStdout,
+        ChildStderr,
+        ChildStdin,
+    )> {
         let mut child = TokioCommandWrap::with_new(SHELL, |cmd| {
             cmd.current_dir(cwd)
-                .stdin(std::process::Stdio::null())
+                .stdin(std::process::Stdio::piped())
                 .stdout(std::process::Stdio::piped())
                 .stderr(std::process::Stdio::piped());
 
@@ -164,20 +194,28 @@ impl ProcessRegistry {
             .take()
             .ok_or_else(|| anyhow::anyhow!("Failed to get stdout"))?;
 
-        Ok((process, stdout, stderr))
+        let stdin = process
+            .stdin()
+            .take()
+            .ok_or_else(|| anyhow::anyhow!("Failed to get stdin"))?;
+
+        Ok((process, stdout, stderr, stdin))
     }
 
     pub async fn execute_command(&mut self, command: &str, cwd: &str) -> Result<usize> {
         self.counter = self.counter.saturating_add(1);
-        let (process, stdout, stderr) = self.spawn_process(command, cwd).await?;
+        let (process, stdout, stderr, stdin) = self.spawn_process(command, cwd).await?;
         let (tx, rx) = mpsc::unbounded_channel();
         let (t_tx, t_rx) = tokio::sync::oneshot::channel();
+        let (in_tx, in_rx) = mpsc::unbounded_channel();
 
         let runtime = ProcessRuntime {
             _process: process,
             stdout,
             stderr,
+            stdin,
             sender: tx,
+            input_signal: in_rx,
             terminate_signal: t_rx,
         };
 
@@ -191,6 +229,7 @@ impl ProcessRegistry {
                 exit_status: None,
                 receiver: rx,
                 terminate_sender: Some(t_tx),
+                input_sender: Some(in_tx),
             },
         );
         Ok(self.counter)
@@ -214,7 +253,11 @@ impl ProcessRegistry {
                 while let Ok(output) = process.receiver.try_recv() {
                     match output {
                         ProcessOutput::Exited(exit_status) => {
-                            process.exit_status = Some(exit_status)
+                            process.exit_status = Some(
+                                exit_status
+                                    .map(|s| s.code().unwrap_or_default())
+                                    .unwrap_or(1),
+                            )
                         }
                         ProcessOutput::Output(str) => process.output += &str,
                         ProcessOutput::Error(str) => process.output += &str,
@@ -231,12 +274,12 @@ impl ProcessRegistry {
         modified_terminal_states
     }
 
-    pub fn get_process(&self, id: usize) -> Option<(Option<ExitStatus>, &String)> {
+    pub fn get_process(&self, id: usize) -> Option<(Option<i32>, &String)> {
         let process = self.processes.get(&id)?;
         Some((process.exit_status, &process.output))
     }
 
-    pub fn processes(&self) -> impl Iterator<Item = (usize, Option<ExitStatus>, &String)> {
+    pub fn processes(&self) -> impl Iterator<Item = (usize, Option<i32>, &String)> {
         self.processes
             .iter()
             .map(|(key, value)| (*key, value.exit_status, &value.command))
@@ -253,4 +296,12 @@ impl ProcessRegistry {
         }
         Ok(())
     }
+
+    pub fn send_data(&self, idx: usize, data: Vec<u8>) {
+        if let Some(process) = self.processes.get(&idx) {
+            if let Some(sender) = process.input_sender.as_ref() {
+                sender.send(data).ok();
+            }
+        }
+    }
 }
diff --git a/src/tools/execute_command/tools.rs b/src/tools/execute_command/tools.rs
@@ -133,9 +133,7 @@ impl Tool for ExecuteCommandTool {
                 if let Some(exit_status) = exit_status {
                     return Ok(format!(
                         "Command ID: {}\nExit Status: Exited({})\nOutput:\n{}",
-                        command_id,
-                        exit_status.code().unwrap_or_default(),
-                        output
+                        command_id, exit_status, output
                     ));
                 }
                 command_output = output.to_string();
@@ -194,9 +192,7 @@ impl Tool for GetCommandResultTool {
             if let Some(exit_status) = exit_status {
                 Ok(format!(
                     "Command ID: {}\nExit Status: Exited({})\nOutput:\n{}",
-                    args.command_id,
-                    exit_status.code().unwrap_or_default(),
-                    output
+                    args.command_id, exit_status, output
                 ))
             } else {
                 Ok(format!(
diff --git a/src/tui/app.rs b/src/tui/app.rs
@@ -1,6 +1,7 @@
 // Copyright © 2025 Huly Labs. Use of this source code is governed by the MIT license.
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
+use std::vec;
 
 use crate::agent::event::{AgentCommandStatus, AgentState};
 use crate::config::Config;
@@ -83,7 +84,6 @@ pub struct UiState<'a> {
     pub textarea: TextArea<'a>,
     pub focus: FocusedComponent,
     pub tree_state: FileTreeState,
-    pub history_scroll_state: ScrollbarState,
     pub history_state: ListState,
     pub history_opened_state: HashSet<usize>,
     pub throbber_state: throbber_widgets_tui::ThrobberState,
@@ -107,7 +107,6 @@ impl UiState<'_> {
         Self {
             textarea: TextArea::default(),
             focus: FocusedComponent::Input,
-            history_scroll_state: ScrollbarState::default(),
             tree_state: FileTreeState::new(workspace),
             history_state: ListState::default(),
             history_opened_state: HashSet::default(),
@@ -194,6 +193,48 @@ impl App<'_> {
                                         &mut self.ui.terminal_state,
                                         &event,
                                     );
+                                    if key_event.kind == KeyEventKind::Press {
+                                        let input_data = match key_event.code {
+                                            KeyCode::Char(ch) => {
+                                                if ch == 'c'
+                                                    && key_event.modifiers == KeyModifiers::CONTROL
+                                                {
+                                                    vec![3]
+                                                } else {
+                                                    vec![ch as u8]
+                                                }
+                                            }
+                                            KeyCode::Enter => {
+                                                vec![b'\n']
+                                            }
+                                            KeyCode::Down
+                                                if key_event.modifiers == KeyModifiers::ALT =>
+                                            {
+                                                vec![b'\x1b', b'[', b'B']
+                                            }
+                                            KeyCode::Up
+                                                if key_event.modifiers == KeyModifiers::ALT =>
+                                            {
+                                                vec![b'\x1b', b'[', b'A']
+                                            }
+                                            _ => {
+                                                vec![]
+                                            }
+                                        };
+                                        if !input_data.is_empty() {
+                                            tracing::trace!(
+                                                "Sending data to terminal: {} {:?}",
+                                                self.ui.terminal_state.selected_idx,
+                                                input_data
+                                            );
+                                            self.agent_sender
+                                                .send(AgentControlEvent::TerminalData(
+                                                    self.ui.terminal_state.selected_idx + 1,
+                                                    input_data,
+                                                ))
+                                                .unwrap()
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -383,11 +424,11 @@ impl App<'_> {
                         terminal_state.selected_idx = idx - 1;
                         terminal_state.scroll_position = 0;
                     }
-                    KeyCode::Down => {
+                    KeyCode::Down if key_event.modifiers != KeyModifiers::ALT => {
                         terminal_state.scroll_position =
                             terminal_state.scroll_position.saturating_add(1);
                     }
-                    KeyCode::Up => {
+                    KeyCode::Up if key_event.modifiers != KeyModifiers::ALT => {
                         terminal_state.scroll_position =
                             terminal_state.scroll_position.saturating_sub(1);
                     }
diff --git a/src/tui/widgets.rs b/src/tui/widgets.rs
@@ -160,7 +160,6 @@ impl Widget for &mut App<'_> {
             .border_style(theme.border_style(matches!(self.ui.focus, FocusedComponent::History)));
 
         let chat_len = self.model.messages.len();
-        self.ui.history_scroll_state = self.ui.history_scroll_state.content_length(chat_len);
 
         let builder = ListBuilder::new(|context| {
             let item = MessageWidget::new(

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,8 @@ pub enum AgentOutputEvent {`
`67`	`67`	`#[derive(Clone, Debug)]`
`68`	`68`	`pub enum AgentControlEvent {`
`69`	`69`	`SendMessage(String),`
	`70`	`+ /// Sends data to stdin of running terminal by idx`
	`71`	`+ TerminalData(usize, Vec<u8>),`
`70`	`72`	`CancelTask,`
`71`	`73`	`NewTask,`
`72`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -655,6 +655,9 @@ impl Agent {`
`655`	`655`	`self.sender.send(AgentOutputEvent::NewTask).ok();`
`656`	`656`	`persist_history(&self.messages);`
`657`	`657`	`}`
	`658`	`+ AgentControlEvent::TerminalData(idx, data) => {`
	`659`	`+ self.process_registry.read().await.send_data(idx, data);`
	`660`	`+ }`
`658`	`661`	`}`
`659`	`662`	`}`
`660`	`663`	`if let Err(e) = self.process_messages(system_prompt_token_count).await {`