chore: refine the code

replace GDBCommandReponse with Ok(String) or AppError

Signed-off-by: Lix Zhou 

Author: pansila

src/bin/gdb_client.rs

@@ -7,7 +7,7 @@ use mcp_core::{
     transport::{ClientSseTransport, ClientSseTransportBuilder, ClientStdioTransport},
     types::{ClientCapabilities, Implementation, ToolResponseContent},
 };
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use tracing::{debug, info};
 use tracing_subscriber::{EnvFilter, layer::SubscriberExt, util::SubscriberInitExt};
 
@@ -42,7 +42,11 @@ struct Args {
 }
 
 // Helper function to call the call_tool method on any type of client
-async fn call_tool(client: &Box<dyn Any>, tool_name: &str, params: Option<Value>) -> Result<Vec<ToolResponseContent>> {
+async fn call_tool(
+    client: &Box<dyn Any>,
+    tool_name: &str,
+    params: Option<Value>,
+) -> Result<Vec<ToolResponseContent>> {
     info!("Calling tool: {}", tool_name);
     debug!("Params: {:?}", params);
     if let Some(client) = client.downcast_ref::<Client<ClientStdioTransport>>() {
@@ -75,8 +79,10 @@ async fn main() -> Result<()> {
     // Create client based on transport type
     let client: Box<dyn Any> = match args.transport {
         TransportType::Stdio => {
-            let transport =
-                ClientStdioTransport::new("./target/debug/mcp_server_gdb", &["--log-level", "debug"])?;
+            let transport = ClientStdioTransport::new(
+                "./target/debug/mcp_server_gdb",
+                &["--log-level", "debug"],
+            )?;
             let client = ClientBuilder::new(transport).build();
 
             // Connect to server
@@ -111,7 +117,8 @@ async fn main() -> Result<()> {
     let session_response = call_tool(
         &client,
         "create_session",
-        args.executable.map(|path| json!({ "executable_path": path })),
+        args.executable
+            .map(|path| json!({ "executable_path": path })),
     )
     .await?;
 

src/error.rs

@@ -6,6 +6,9 @@ pub enum AppError {
     #[error("GDB error: {0}")]
     GDBError(String),
 
+    #[error("GDB timeout")]
+    GDBTimeout,
+
     #[error("Parse error: {0}")]
     #[allow(dead_code)]
     ParseError(String),

src/gdb.rs

@@ -16,7 +16,7 @@ use uuid::Uuid;
 use crate::{
     config::Config,
     error::{AppError, AppResult},
-    models::{Breakpoint, GDBCommandResponse, GDBSession, GDBSessionStatus, StackFrame, Variable},
+    models::{Breakpoint, GDBSession, GDBSessionStatus, StackFrame, Variable},
 };
 
 /// GDB Session Manager
@@ -148,7 +148,7 @@ impl GDBManager {
         &self,
         session_id: &str,
         command: &str,
-    ) -> AppResult<GDBCommandResponse> {
+    ) -> AppResult<String> {
         let sessions = self.sessions.read().await;
         let handle = sessions
             .get(session_id)
@@ -158,24 +158,20 @@ impl GDBManager {
 
         // Parse output
         let success = !output.contains("^error");
-        let error = if !success {
+        if !success {
             // Extract error message
             static ERROR_REGEX: LazyLock<Regex> =
                 LazyLock::new(|| Regex::new(r#"\^error,msg="(.+)""#).unwrap());
 
-            ERROR_REGEX
+            let error = ERROR_REGEX
                 .captures(&output)
                 .and_then(|caps| caps.get(1))
                 .map(|m| m.as_str().to_string())
-        } else {
-            None
-        };
+                .unwrap_or_else(|| "Unknown error".to_string());
+            return Err(AppError::GDBError(error));
+        }
 
-        Ok(GDBCommandResponse {
-            success,
-            output,
-            error,
-        })
+        Ok(output)
     }
 
     /// Send raw command to GDB
@@ -250,66 +246,50 @@ impl GDBManager {
         &self,
         session_id: &str,
         command: &str,
-    ) -> AppResult<GDBCommandResponse> {
+    ) -> AppResult<String> {
         let command_timeout = self.config.command_timeout;
         match tokio::time::timeout(
             Duration::from_secs(command_timeout),
             self.send_command(session_id, command),
         )
         .await
         {
-            Ok(result) => result,
-            Err(_) => Err(AppError::GDBError(format!(
-                "GDB command '{}' timed out",
-                command
-            ))),
+            Ok(Ok(result)) => {
+                Ok(result)
+            }
+            Ok(Err(e)) => Err(e),
+            Err(_) => Err(AppError::GDBTimeout),
         }
     }
 
     /// Start debugging
-    pub async fn start_debugging(&self, session_id: &str) -> AppResult<()> {
+    pub async fn start_debugging(&self, session_id: &str) -> AppResult<String> {
         let response = self
             .send_command_with_timeout(session_id, "-exec-run")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to start debugging".to_string()),
-            ));
-        }
-
         // Update session status
         let mut sessions = self.sessions.write().await;
         if let Some(handle) = sessions.get_mut(session_id) {
             handle.info.status = GDBSessionStatus::Running;
         }
 
-        Ok(())
+        Ok(response)
     }
 
     /// Stop debugging
-    pub async fn stop_debugging(&self, session_id: &str) -> AppResult<()> {
+    pub async fn stop_debugging(&self, session_id: &str) -> AppResult<String> {
         let response = self
             .send_command_with_timeout(session_id, "-exec-interrupt")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to stop debugging".to_string()),
-            ));
-        }
-
         // Update session status
         let mut sessions = self.sessions.write().await;
         if let Some(handle) = sessions.get_mut(session_id) {
             handle.info.status = GDBSessionStatus::Stopped;
         }
 
-        Ok(())
+        Ok(response)
     }
 
     /// Get breakpoint list
@@ -318,14 +298,6 @@ impl GDBManager {
             .send_command_with_timeout(session_id, "-break-list")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to get breakpoint list".to_string()),
-            ));
-        }
-
         // Parse breakpoint information (simplified version, actually needs more complex parsing)
         let breakpoints = Vec::new();
 
@@ -345,14 +317,6 @@ impl GDBManager {
         let command = format!("-break-insert {}:{}", file, line);
         let response = self.send_command_with_timeout(session_id, &command).await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to set breakpoint".to_string()),
-            ));
-        }
-
         // Parse breakpoint ID (simplified)
         let breakpoint_id = Uuid::new_v4().to_string(); // Should actually be extracted from response
 
@@ -365,19 +329,15 @@ impl GDBManager {
     }
 
     /// Delete breakpoint
-    pub async fn delete_breakpoint(&self, session_id: &str, breakpoint_id: &str) -> AppResult<()> {
+    pub async fn delete_breakpoint(
+        &self,
+        session_id: &str,
+        breakpoint_id: &str,
+    ) -> AppResult<String> {
         let command = format!("-break-delete {}", breakpoint_id);
         let response = self.send_command_with_timeout(session_id, &command).await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to delete breakpoint".to_string()),
-            ));
-        }
-
-        Ok(())
+        Ok(response)
     }
 
     /// Get stack frames
@@ -386,14 +346,6 @@ impl GDBManager {
             .send_command_with_timeout(session_id, "-stack-list-frames")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to get stack frames".to_string()),
-            ));
-        }
-
         // Parse stack frame information (simplified)
         let frames = Vec::new(); // Actually needs to parse response
 
@@ -409,74 +361,42 @@ impl GDBManager {
         let command = format!("-stack-list-variables --frame {} --simple-values", frame_id);
         let response = self.send_command_with_timeout(session_id, &command).await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to get local variables".to_string()),
-            ));
-        }
-
         // Parse variable information (simplified)
         let variables = Vec::new(); // Actually needs to parse response
 
         Ok(variables)
     }
 
     /// Continue execution
-    pub async fn continue_execution(&self, session_id: &str) -> AppResult<()> {
+    pub async fn continue_execution(&self, session_id: &str) -> AppResult<String> {
         let response = self
             .send_command_with_timeout(session_id, "-exec-continue")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to continue execution".to_string()),
-            ));
-        }
-
         // Update session status
         let mut sessions = self.sessions.write().await;
         if let Some(handle) = sessions.get_mut(session_id) {
             handle.info.status = GDBSessionStatus::Running;
         }
 
-        Ok(())
+        Ok(response)
     }
 
     /// Step execution
-    pub async fn step_execution(&self, session_id: &str) -> AppResult<()> {
+    pub async fn step_execution(&self, session_id: &str) -> AppResult<String> {
         let response = self
             .send_command_with_timeout(session_id, "-exec-step")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to step execution".to_string()),
-            ));
-        }
-
-        Ok(())
+        Ok(response)
     }
 
     /// Next execution
-    pub async fn next_execution(&self, session_id: &str) -> AppResult<()> {
+    pub async fn next_execution(&self, session_id: &str) -> AppResult<String> {
         let response = self
             .send_command_with_timeout(session_id, "-exec-next")
             .await?;
 
-        if !response.success {
-            return Err(AppError::GDBError(
-                response
-                    .error
-                    .unwrap_or_else(|| "Failed to execute next step".to_string()),
-            ));
-        }
-
-        Ok(())
+        Ok(response)
     }
 }

src/models.rs

@@ -33,17 +33,6 @@ pub struct GDBCommandRequest {
     pub command: String,
 }
 
-/// GDB command response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GDBCommandResponse {
-    /// Success status
-    pub success: bool,
-    /// Response content
-    pub output: String,
-    /// Error message (if any)
-    pub error: Option<String>,
-}
-
 /// Create session request
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CreateSessionRequest {