refactor: cleaning up unused traits and their methods (#14)

* fix: update SSE URL to use localhost and adjust server readiness poll timeout

* refactor: implement exponential backoff for server readiness polling

* refactor: remove DynRunnerProcessManager and clean up unused traits and simplify process manager interfaces

* [autofix.ci] apply automated fixes

* [autofix.ci] apply automated fixes (attempt 2/3)

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: thesapan

crates/gpmcp-layer-core/src/layer.rs

@@ -1,6 +1,6 @@
 use crate::config::{RetryConfig, RunnerConfig};
 use crate::error::GpmcpError;
-use crate::process_manager_trait::DynRunnerProcessManager;
+use crate::process_manager_trait::RunnerProcessManager;
 use crate::runner::inner::GpmcpRunnerInner;
 use backon::{ExponentialBuilder, Retryable};
 use std::future::Future;
@@ -13,17 +13,14 @@ pub struct Initialized;
 pub struct Uninitialized;
 
 #[derive(Clone)]
-pub struct GpmcpLayer<Status> {
+pub struct GpmcpLayer<Status, Manager> {
     runner_config: RunnerConfig,
-    process_manager: Arc<dyn DynRunnerProcessManager>,
-    inner: Arc<Mutex<GpmcpRunnerInner<Status>>>,
+    process_manager: Arc<Manager>,
+    inner: Arc<Mutex<GpmcpRunnerInner<Status, Manager>>>,
     retry_config: ExponentialBuilder,
 }
-impl GpmcpLayer<Uninitialized> {
-    pub fn new(
-        runner_config: RunnerConfig,
-        process_manager: Arc<dyn DynRunnerProcessManager>,
-    ) -> Self {
+impl<Manager: RunnerProcessManager> GpmcpLayer<Uninitialized, Manager> {
+    pub fn new(runner_config: RunnerConfig, process_manager: Arc<Manager>) -> Self {
         Self {
             inner: Arc::new(Mutex::new(GpmcpRunnerInner::new(
                 runner_config.clone(),
@@ -34,7 +31,7 @@ impl GpmcpLayer<Uninitialized> {
             process_manager,
         }
     }
-    pub async fn connect(self) -> Result<GpmcpLayer<Initialized>, GpmcpError> {
+    pub async fn connect(self) -> Result<GpmcpLayer<Initialized, Manager>, GpmcpError> {
         let initialized_inner = self.inner.lock().await.connect().await?;
         Ok(GpmcpLayer {
             runner_config: self.runner_config,
@@ -57,7 +54,7 @@ impl GpmcpLayer<Uninitialized> {
         retry_builder
     }
 }
-impl GpmcpLayer<Initialized> {
+impl<Manager: RunnerProcessManager> GpmcpLayer<Initialized, Manager> {
     /// Generic retry mechanism for operations that may fail due to connection issues
     /// Uses backon library with GpmcpError.is_retryable() to determine if an error should be retried
     async fn attempt_with_retry<T, F, Fut>(&self, operation: F) -> Result<T, GpmcpError>

crates/gpmcp-layer-core/src/process.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use std::collections::HashMap;
-use std::time::Duration;
 
 /// Unique identifier for a process
 pub type ProcessId = u32;
@@ -82,85 +81,16 @@ pub trait ProcessLifecycle: Send + Sync {
         working_dir: Option<&str>,
         env: &HashMap<String, String>,
     ) -> Result<Self::Handle>;
-
-    /// Check if a process is still running and healthy
-    async fn is_process_healthy(&self, handle: &dyn ProcessHandle) -> bool;
-
-    /// Get detailed information about a process
-    async fn get_process_info(&self, handle: &dyn ProcessHandle) -> Result<ProcessInfo>;
-
-    /// Wait for a process to exit with optional timeout
-    async fn wait_for_exit(
-        &self,
-        handle: &mut dyn ProcessHandle,
-        timeout: Option<Duration>,
-    ) -> Result<ProcessStatus>;
 }
 
 /// Trait for comprehensive process termination including process trees
 #[async_trait]
 pub trait ProcessTermination: Send + Sync {
-    /// Terminate a single process gracefully (SIGTERM on Unix)
-    async fn terminate_gracefully(&self, handle: &mut dyn ProcessHandle) -> TerminationResult;
-
-    /// Force kill a single process (SIGKILL on Unix)
-    async fn force_kill(&self, handle: &mut dyn ProcessHandle) -> TerminationResult;
-
     /// Find all child processes of a given process
     async fn find_child_processes(&self, pid: ProcessId) -> Result<Vec<ProcessId>>;
 
     /// Terminate an entire process tree (parent and all descendants)
     async fn terminate_process_tree(&self, root_pid: ProcessId) -> TerminationResult;
-
-    /// Terminate a process group (Unix only, returns ProcessNotFound on Windows)
-    async fn terminate_process_group(&self, pid: ProcessId) -> TerminationResult;
-
-    /// Complete termination strategy: process group -> process tree -> individual process
-    async fn terminate_completely(&self, handle: &mut dyn ProcessHandle) -> TerminationResult {
-        if let Some(pid) = handle.get_pid() {
-            // Step 1: Try process group termination (Unix only)
-            match self.terminate_process_group(pid).await {
-                TerminationResult::Success => return TerminationResult::Success,
-                TerminationResult::ProcessNotFound => {
-                    // Process group not found, continue to next step
-                }
-                _ => {
-                    // Process group termination failed, try process tree
-                }
-            }
-
-            // Step 2: Try process tree termination
-            match self.terminate_process_tree(pid).await {
-                TerminationResult::Success => return TerminationResult::Success,
-                TerminationResult::ProcessNotFound => {
-                    // Process tree not found, continue to individual termination
-                }
-                _ => {
-                    // Process tree termination failed, continue to individual termination
-                }
-            }
-        }
-
-        // Step 3: Individual process termination with escalation
-        match self.terminate_gracefully(handle).await {
-            TerminationResult::Success => {
-                // Wait a bit to see if process exits gracefully
-                tokio::time::sleep(Duration::from_millis(1000)).await;
-
-                // If still running, force kill
-                if handle.is_running().await {
-                    self.force_kill(handle).await
-                } else {
-                    TerminationResult::Success
-                }
-            }
-            TerminationResult::ProcessNotFound => TerminationResult::Success,
-            _ => {
-                // Graceful termination failed, try force kill
-                self.force_kill(handle).await
-            }
-        }
-    }
 }
 
 /// Trait representing a handle to a running process
@@ -172,18 +102,6 @@ pub trait ProcessHandle: Send + Sync {
     /// Get the command that started this process
     fn get_command(&self) -> &str;
 
-    /// Get the arguments passed to this process
-    fn get_args(&self) -> &[String];
-
-    /// Check if the process is still running (non-blocking)
-    async fn is_running(&self) -> bool;
-
-    /// Try to get exit status without blocking
-    async fn try_wait(&mut self) -> Result<Option<ProcessStatus>>;
-
-    /// Wait for the process to exit (blocking)
-    async fn wait(&mut self) -> Result<ProcessStatus>;
-
     /// Kill the process (platform-specific implementation)
     async fn kill(&mut self) -> Result<()>;
 }
@@ -207,9 +125,6 @@ pub trait ProcessManagerFactory {
 
     /// Create a process manager for the current platform
     fn create_process_manager() -> Self::Manager;
-
-    /// Get the platform name for logging and debugging
-    fn platform_name() -> &'static str;
 }
 
 /// Implementation of ProcessHandle for boxed trait objects to enable associated type usage
@@ -223,22 +138,6 @@ impl ProcessHandle for Box<dyn ProcessHandle> {
         (**self).get_command()
     }
 
-    fn get_args(&self) -> &[String] {
-        (**self).get_args()
-    }
-
-    async fn is_running(&self) -> bool {
-        (**self).is_running().await
-    }
-
-    async fn try_wait(&mut self) -> Result<Option<ProcessStatus>> {
-        (**self).try_wait().await
-    }
-
-    async fn wait(&mut self) -> Result<ProcessStatus> {
-        (**self).wait().await
-    }
-
     async fn kill(&mut self) -> Result<()> {
         (**self).kill().await
     }

crates/gpmcp-layer-core/src/process_manager_trait.rs

@@ -1,9 +1,8 @@
 use anyhow::Result;
 use async_trait::async_trait;
-use std::collections::HashMap;
 
 use crate::config::RunnerConfig;
-use crate::process::{ProcessHandle, ProcessId};
+use crate::process::ProcessHandle;
 
 /// High-level process manager trait for platform-independent process orchestration
 ///
@@ -93,41 +92,6 @@ pub trait RunnerProcessManager: Send + Sync {
     /// ```
     async fn start_server(&self) -> Result<Self::Handle>;
 
-    /// Spawn a new process with the given parameters and track it for cleanup
-    ///
-    /// This method spawns a process with the specified command and arguments, optionally
-    /// setting a working directory and environment variables. The spawned process will
-    /// be automatically tracked and included in cleanup operations.
-    ///
-    /// # Arguments
-    ///
-    /// * `command` - The command to execute
-    /// * `args` - Command-line arguments for the process
-    /// * `working_dir` - Optional working directory for the process
-    /// * `env` - Optional environment variables for the process
-    ///
-    /// # Returns
-    ///
-    /// Returns a handle to the spawned process or an error if spawning fails.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// // let handle = manager.spawn_process(
-    /// //     "node",
-    /// //     &["script.js".to_string()],
-    /// //     Some("/path/to/working/dir"),
-    /// //     Some(&env_vars)
-    /// // ).await?;
-    /// ```
-    async fn spawn_process(
-        &self,
-        command: &str,
-        args: &[String],
-        working_dir: Option<&str>,
-        env: Option<&HashMap<String, String>>,
-    ) -> Result<Self::Handle>;
-
     /// Cleanup all tracked processes and release resources
     ///
     /// This method performs coordinated cleanup of all processes managed by this instance.
@@ -154,95 +118,6 @@ pub trait RunnerProcessManager: Send + Sync {
     /// // manager.cleanup().await?;
     /// ```
     async fn cleanup(&self) -> Result<()>;
-
-    /// Get the number of currently tracked active processes
-    ///
-    /// This method returns the count of processes currently being tracked by this
-    /// process manager instance. This can be useful for monitoring and debugging.
-    ///
-    /// # Returns
-    ///
-    /// Returns the number of active tracked processes.
-    fn active_process_count(&self) -> usize;
-
-    /// Get information about all currently tracked processes
-    ///
-    /// This method returns a snapshot of all currently tracked processes, including
-    /// their process IDs and the commands that started them. This is useful for
-    /// monitoring and debugging purposes.
-    ///
-    /// # Returns
-    ///
-    /// Returns a vector of tuples containing (ProcessId, command_name) for each
-    /// tracked process.
-    fn get_tracked_processes(&self) -> Vec<(ProcessId, String)>;
-}
-
-/// Trait object-safe version of RunnerProcessManager for dynamic dispatch
-///
-/// This trait provides the same interface as RunnerProcessManager but uses boxed
-/// trait objects for return types, making it suitable for use in trait objects.
-/// This allows for dynamic dispatch when needed while still providing the
-/// associated type version for static dispatch scenarios.
-#[async_trait]
-pub trait DynRunnerProcessManager: Send + Sync {
-    /// Start the server process using the configuration provided during construction
-    async fn start_server(&self) -> Result<Box<dyn ProcessHandle>>;
-
-    /// Spawn a new process with the given parameters and track it for cleanup
-    async fn spawn_process(
-        &self,
-        command: &str,
-        args: &[String],
-        working_dir: Option<&str>,
-        env: Option<&HashMap<String, String>>,
-    ) -> Result<Box<dyn ProcessHandle>>;
-
-    /// Cleanup all tracked processes and release resources
-    async fn cleanup(&self) -> Result<()>;
-
-    /// Get the number of currently tracked active processes
-    fn active_process_count(&self) -> usize;
-
-    /// Get information about all currently tracked processes
-    fn get_tracked_processes(&self) -> Vec<(ProcessId, String)>;
-}
-
-/// Blanket implementation to automatically provide DynRunnerProcessManager for any RunnerProcessManager
-#[async_trait]
-impl<T> DynRunnerProcessManager for T
-where
-    T: RunnerProcessManager + Send + Sync,
-    T::Handle: 'static,
-{
-    async fn start_server(&self) -> Result<Box<dyn ProcessHandle>> {
-        let handle = RunnerProcessManager::start_server(self).await?;
-        Ok(Box::new(handle))
-    }
-
-    async fn spawn_process(
-        &self,
-        command: &str,
-        args: &[String],
-        working_dir: Option<&str>,
-        env: Option<&HashMap<String, String>>,
-    ) -> Result<Box<dyn ProcessHandle>> {
-        let handle =
-            RunnerProcessManager::spawn_process(self, command, args, working_dir, env).await?;
-        Ok(Box::new(handle))
-    }
-
-    async fn cleanup(&self) -> Result<()> {
-        RunnerProcessManager::cleanup(self).await
-    }
-
-    fn active_process_count(&self) -> usize {
-        RunnerProcessManager::active_process_count(self)
-    }
-
-    fn get_tracked_processes(&self) -> Vec<(ProcessId, String)> {
-        RunnerProcessManager::get_tracked_processes(self)
-    }
 }
 
 /// Factory trait for creating platform-specific RunnerProcessManager implementations
@@ -262,10 +137,7 @@ where
 /// //     async fn create_process_manager(config: &RunnerConfig) -> Result<Self::Manager> {
 /// //         UnixRunnerProcessManager::new(config).await
 /// //     }
-/// //     
-/// //     fn platform_name() -> &'static str {
-/// //         "unix"
-/// //     }
+/// //
 /// // }
 /// ```
 #[async_trait]
@@ -283,11 +155,4 @@ pub trait RunnerProcessManagerFactory {
     ///
     /// Returns a new process manager instance or an error if creation fails.
     fn create_process_manager(config: &RunnerConfig) -> Self::Manager;
-
-    /// Get the platform name for logging and debugging
-    ///
-    /// # Returns
-    ///
-    /// Returns a static string identifying the platform (e.g., "windows", "unix").
-    fn platform_name() -> &'static str;
 }