handles sigint

Author: dingfeli

crates/chat-cli-ui/src/conduit.rs

@@ -1,6 +1,8 @@
+use std::future;
 use std::io::Write as _;
 use std::marker::PhantomData;
 use std::path::PathBuf;
+use std::pin::Pin;
 
 use crossterm::style::{
     self,
@@ -12,6 +14,7 @@ use crossterm::{
     queue,
 };
 use rustyline::EditMode;
+use tokio::signal::ctrl_c;
 use tracing::error;
 
 use crate::legacy_ui_util::{
@@ -49,19 +52,36 @@ pub enum ConduitError {
 /// - To deliver state changes from the control layer to the view layer
 pub struct ViewEnd {
     /// Used by the view to send input to the control
-    // TODO: later on we will need replace this byte array with an actual event type from ACP
     pub sender: tokio::sync::mpsc::Sender<InputEvent>,
     /// To receive messages from control about state changes
     pub receiver: tokio::sync::mpsc::UnboundedReceiver<Event>,
 }
 
 impl ViewEnd {
-    /// Method to facilitate in the interim
-    /// It takes possible messages from the old even loop and queues write to the output provided
-    /// This blocks the current thread and consumes the [ViewEnd]
+    /// Converts the ViewEnd into legacy mode operation. This mainly serves a purpose in the
+    /// following circumstances:
+    /// - To preserve the UX of the current event loop while abstracting away the impl Write it
+    ///   writes to
+    /// - To serve as an interim UI for the new event loop while preserving the UX of the current
+    ///   product while the new UI is being worked out
+    ///
+    /// # Parameters
+    ///
+    /// * `ui_managed_input` - When true, the UI layer will manage user input through readline. When
+    ///   false, input handling is delegated to the event loop (via InputSource).
+    /// * `ui_managed_ctrl_c` - When true, the UI layer will handle Ctrl+C interrupts. When false,
+    ///   interrupt handling is delegated to the event loop (via its own ctrl c handler).
+    /// * `theme_source` - Provider for terminal styling and theming information.
+    /// * `stderr` - Standard error stream for error output.
+    /// * `stdout` - Standard output stream for normal output.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` on successful initialization, or a `ConduitError` if setup fails.
     pub fn into_legacy_mode(
         mut self,
-        managed_input: bool,
+        ui_managed_input: bool,
+        ui_managed_ctrl_c: bool,
         theme_source: impl ThemeSource,
         mut stderr: std::io::Stderr,
         mut stdout: std::io::Stdout,
@@ -254,7 +274,7 @@ impl ViewEnd {
             Ok::<(), ConduitError>(())
         }
 
-        if managed_input {
+        if ui_managed_input {
             let (incoming_events_tx, mut incoming_events_rx) = tokio::sync::mpsc::unbounded_channel::<IncomingEvent>();
             let (prompt_signal_tx, prompt_signal_rx) = std::sync::mpsc::channel::<PromptSignal>();
 
@@ -303,15 +323,27 @@ impl ViewEnd {
                 let prompt_signal = PromptSignal::default();
 
                 loop {
+                    let ctrl_c_handler: Pin<
+                        Box<dyn Future<Output = Result<(), std::io::Error>> + Send + Sync + 'static>,
+                    >;
+
                     if matches!(display_state, DisplayState::Prompting) {
-                        // TODO: fetch prompt related info from session and send it here
                         if let Err(e) = prompt_signal_tx.send(prompt_signal.clone()) {
                             error!("Error sending prompt signal: {:?}", e);
                         }
                         display_state = DisplayState::UserInsertingText;
+
+                        ctrl_c_handler = Box::pin(future::pending());
+                    } else if ui_managed_ctrl_c {
+                        ctrl_c_handler = Box::pin(ctrl_c());
+                    } else {
+                        ctrl_c_handler = Box::pin(future::pending());
                     }
 
                     tokio::select! {
+                        _ = ctrl_c_handler => {
+                            _ = self.sender.send(InputEvent::Interrupt).await;
+                        },
                         Some(incoming_event) = incoming_events_rx.recv() => {
                             match display_state {
                                 DisplayState::UserInsertingText => {
@@ -323,10 +355,8 @@ impl ViewEnd {
                                             display_state = DisplayState::StreamingOutput;
                                         },
                                         IncomingEvent::Interrupt => {
-                                            // If user is still inputting text, the session does
-                                            // not need to be notified that they are hitting
-                                            // control c.
                                             display_state = DisplayState::default();
+                                            _ = self.sender.send(InputEvent::Interrupt).await;
                                         },
                                     }
                                 },

crates/chat-cli-ui/src/legacy_ui_util.rs

@@ -123,7 +123,7 @@ impl Completer for ChatCompleter {
         if line.starts_with('@') {
             let search_word = line.strip_prefix('@').unwrap_or("");
             // Here we assume that the names given by the event loop is already namespaced
-            // approriately (i.e. not namespaced if the prompt name is unique and namespaced with
+            // appropriately (i.e. not namespaced if the prompt name is unique and namespaced with
             // their respective server if it is)
             let completions = self
                 .available_prompts

crates/chat-cli/src/cli/chat/managed_input.rs

@@ -0,0 +1 @@
+

crates/chat-cli/src/cli/chat/mod.rs

@@ -645,7 +645,7 @@ impl ChatSession {
 
         let stderr = std::io::stderr();
         let stdout = std::io::stdout();
-        if let Err(e) = view_end.into_legacy_mode(should_use_ui_managed_input, StyledText, stderr, stdout) {
+        if let Err(e) = view_end.into_legacy_mode(should_use_ui_managed_input, false, StyledText, stderr, stdout) {
             error!("Conduit view end legacy mode exited: {:?}", e);
         }
 
@@ -1962,7 +1962,7 @@ impl ChatSession {
                 meta_type: "timing".to_string(),
                 payload: serde_json::Value::String("prompt_user".to_string()),
             }))?;
-            self.read_user_input_managed().await
+            self.read_user_input_via_ui().await
         } else {
             let prompt = self.generate_tool_trust_prompt(os).await;
             self.read_user_input(&prompt, false)
@@ -1973,7 +1973,11 @@ impl ChatSession {
         };
 
         // Check if there's a pending clipboard paste from Ctrl+V
-        let pasted_paths = self.input_source.take_clipboard_pastes();
+        let pasted_paths = self
+            .input_source
+            .as_mut()
+            .map(|input_source| input_source.take_clipboard_pastes())
+            .unwrap_or_default();
         if !pasted_paths.is_empty() {
             // Check if the input contains image markers
             let image_marker_regex = regex::Regex::new(r"\[Image #\d+\]").unwrap();
@@ -1986,7 +1990,9 @@ impl ChatSession {
                     .join(" ");
 
                 // Reset the counter for next message
-                self.input_source.reset_paste_count();
+                if let Some(input_source) = self.input_source.as_mut() {
+                    input_source.reset_paste_count();
+                }
 
                 // Return HandleInput with all paths to automatically process the images
                 return Ok(ChatState::HandleInput { input: paths_str });
@@ -1997,13 +2003,39 @@ impl ChatSession {
         Ok(ChatState::HandleInput { input: user_input })
     }
 
-    async fn read_user_input_managed(&mut self) -> Option<String> {
+    async fn read_user_input_via_ui(&mut self) -> Option<String> {
         if let Some(managed_input) = &mut self.managed_input {
-            if let Some(content) = managed_input.recv().await {
-                if let InputEvent::Text(content) = content {
-                    return Some(content);
-                } else {
-                    return None;
+            let mut has_hit_ctrl_c = false;
+            while let Some(input_event) = managed_input.recv().await {
+                match input_event {
+                    InputEvent::Text(content) => {
+                        return Some(content);
+                    },
+                    InputEvent::Interrupt => {
+                        if has_hit_ctrl_c {
+                            return None;
+                        } else {
+                            has_hit_ctrl_c = true;
+                            _ = execute!(
+                                self.stderr,
+                                style::Print(format!(
+                                    "\n(To exit the CLI, press Ctrl+C or Ctrl+D again or type {})\n\n",
+                                    "/quit".green()
+                                ))
+                            );
+
+                            if self
+                                .stderr
+                                .send(Event::MetaEvent(chat_cli_ui::protocol::MetaEvent {
+                                    meta_type: "timing".to_string(),
+                                    payload: serde_json::Value::String("prompt_user".to_string()),
+                                }))
+                                .is_err()
+                            {
+                                return None;
+                            }
+                        }
+                    },
                 }
             }
         }

crates/chat-cli/src/util/ui.rs

@@ -160,7 +160,7 @@ fn print_with_bold(output: &mut impl Write, segments: &[(String, bool)]) -> Resu
 /// - structured: This makes the event loop send structured messages where applicable (in addition
 ///   to logging ANSI bytes directly where it has not been instrumented)
 /// - new: This spawns the new UI to be used on top of the current event loop (if we end up enabling
-///   this)
+///   this). This would also require the event loop to emit structured events.
 /// - unset: This is the default behavior where everything is unstructured (i.e. ANSI bytes straight
 ///   to stderr or stdout)
 ///