send response when connected fail

Author: CppCXY

src/context/mod.rs

@@ -70,12 +70,20 @@ impl EmmyLuaDebugContext {
             if let Some(response) = response {
                 match output.lock().unwrap().respond(response) {
                     Err(server_err) => {
-                        log::error!("{:?}", server_err);
-                        // exit
-                        std::process::exit(1);
+                        log::error!(
+                            "Failed to send response for request {}: {:?}",
+                            req_id,
+                            server_err
+                        );
+                        // Don't exit - DAP clients expect responses even on errors
+                        // The error will be logged and the client should handle the situation
+                    }
+                    Ok(_) => {
+                        log::debug!("Successfully sent response for request {}", req_id);
                     }
-                    Ok(_) => {}
                 }
+            } else {
+                log::warn!("No response generated for request {}", req_id);
             }
 
             let mut cancellations = cancellations.lock().await;
@@ -94,7 +102,11 @@ impl EmmyLuaDebugContext {
         let mut output = self.ide_conn.lock().unwrap();
         let result = output.respond(response);
         if let Err(server_err) = result {
-            log::error!("{:?}", server_err)
+            log::error!("Failed to send response: {:?}", server_err);
+            // Don't panic - log the error and continue
+            // The client should handle missing responses gracefully
+        } else {
+            log::debug!("Successfully sent response");
         }
     }
 }

src/handler/debugger_connected.rs

@@ -14,13 +14,17 @@ pub async fn after_debugger_connected(
     {
         log::info!("on debugger connected");
         let mut ide_conn = dap.ide_conn.lock().unwrap();
-        ide_conn
-            .send_event(Event::Output(OutputEventBody {
-                category: Some(dap::types::OutputEventCategory::Console),
-                output: "Debugger connected\n".to_string(),
-                ..Default::default()
-            }))
-            .map_err(|err| RequestHandlerError::ServerError(err))?;
+        match ide_conn.send_event(Event::Output(OutputEventBody {
+            category: Some(dap::types::OutputEventCategory::Console),
+            output: "Debugger connected\n".to_string(),
+            ..Default::default()
+        })) {
+            Ok(_) => {}
+            Err(err) => {
+                log::error!("Failed to send output event: {:?}", err);
+                // Continue anyway - this is not critical
+            }
+        }
     }
 
     {
@@ -57,9 +61,15 @@ pub async fn after_debugger_connected(
     {
         log::info!("send initialized event to ide");
         let mut ide_conn = dap.ide_conn.lock().unwrap();
-        ide_conn
-            .send_event(Event::Initialized)
-            .map_err(|err| RequestHandlerError::ServerError(err))?;
+        match ide_conn.send_event(Event::Initialized) {
+            Ok(_) => {
+                log::info!("Successfully sent initialized event");
+            }
+            Err(err) => {
+                log::error!("Failed to send initialized event: {:?}", err);
+                return Err(RequestHandlerError::ServerError(err).into());
+            }
+        }
     }
     Ok(())
 }

src/handler/launch_request.rs

@@ -61,18 +61,23 @@ pub async fn on_launch_request(
     data.sources = emmy_new_debug_argument.source_paths.clone();
 
     let dap = dap.clone();
+    let ide_conn = dap.ide_conn.clone();
     tokio::spawn(async move {
         tokio::time::sleep(std::time::Duration::from_millis(200)).await;
         log::info!("Registering debugger notification");
         register_debugger_notification(dap.clone()).await;
 
         log::info!("after debugger connected");
         match after_debugger_connected(dap, emmy_new_debug_argument.ext).await {
-            Ok(_) => {}
+            Ok(_) => {
+                log::info!("Debugger connection fully established");
+            }
             Err(err) => {
                 log::error!("Failed to handle debugger connected: {}", err);
-                // exit
-                std::process::exit(1);
+                // Send a terminated event to notify the client
+                let mut output = ide_conn.lock().unwrap();
+                let _ = output.send_event(dap::events::Event::Terminated(None));
+                // Don't exit - let the client decide what to do
             }
         }
     });