Merge main into feat/tabs - integrate history restore functionality

src-tauri/src/commands.rs

@@ -25,6 +25,12 @@ pub async fn stop_claude(app: AppHandle, bridge: State<'_, SharedBridge>) -> Res
     Ok(())
 }
 
+#[tauri::command]
+pub async fn interrupt_claude(app: AppHandle, bridge: State<'_, SharedBridge>) -> Result<(), String> {
+    let mut bridge = bridge.lock();
+    bridge.interrupt(&app)
+}
+
 #[tauri::command]
 pub async fn send_prompt(bridge: State<'_, SharedBridge>, message: String) -> Result<(), String> {
     let mut bridge = bridge.lock();

src-tauri/src/config.rs

@@ -19,6 +19,9 @@ pub struct ClaudeStartOptions {
 
     #[serde(default)]
     pub allowed_tools: Vec<String>,
+
+    #[serde(default)]
+    pub skip_greeting: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

src-tauri/src/lib.rs

@@ -32,6 +32,7 @@ pub fn run() {
         .invoke_handler(tauri::generate_handler![
             start_claude,
             stop_claude,
+            interrupt_claude,
             send_prompt,
             is_claude_running,
             get_working_directory,

src-tauri/src/wsl_bridge.rs

@@ -332,6 +332,30 @@ impl WslBridge {
         Ok(())
     }
 
+    pub fn interrupt(&mut self, app: &AppHandle) -> Result<(), String> {
+        // Due to persistent bug in Claude Code where ESC/Ctrl+C doesn't work,
+        // we have to kill the process. This is the only reliable way to stop it.
+        // See: https://github.com/anthropics/claude-code/issues/3455
+        if let Some(mut process) = self.process.take() {
+            // Kill the process immediately
+            let _ = process.kill();
+            let _ = process.wait();
+
+            // Clear stdin
+            self.stdin = None;
+
+            // Keep session_id and working directory for user reference
+            // The user will see what session was interrupted
+
+            // Emit disconnected status
+            emit_connection_status(app, ConnectionStatus::Disconnected);
+
+            Ok(())
+        } else {
+            Err("No active process to interrupt".to_string())
+        }
+    }
+
     pub fn stop(&mut self, app: &AppHandle) {
         if let Some(mut process) = self.process.take() {
             let _ = process.kill();