enhance: add timeout monitoring to command-line tools to prevent them…

probing/cli/src/cli/commands.rs

@@ -171,3 +171,26 @@ pub enum Commands {
     #[command(subcommand = false, hide = true)]
     Store(StoreCommand),
 }
+
+impl Commands {
+    /// Determines whether this command should have a timeout applied.
+    /// Long-running commands like Launch and External should not time out.
+    pub fn is_timed_command(&self) -> bool {
+        match self {
+            // Long-running commands - no timeout
+            Commands::Repl => false,
+            Commands::Launch { .. } => false,
+            Commands::External(_) => false,
+            // Short-running commands - apply timeout
+            Commands::List { .. } => true,
+            Commands::Backtrace { .. } => true,
+            Commands::Rdma { .. } => true,
+            Commands::Eval { .. } => true,
+            Commands::Query { .. } => true,
+            Commands::Store(_) => true,
+            Commands::Config { .. } => true,
+            #[cfg(target_os = "linux")]
+            Commands::Inject(_) => true,
+        }
+    }
+}

probing/cli/src/cli/mod.rs

@@ -54,8 +54,11 @@
     #[command(subcommand)]
     command: Option<Commands>,
 }
 
 impl Cli {
+    pub fn should_timeout(&self) -> bool {
+        self.command.as_ref().map_or(true, |cmd| cmd.is_timed_command())
+    }
     pub async fn run(&mut self) -> Result<()> {
         // Handle external commands first to avoid target requirement
         if let Some(Commands::External(args)) = &self.command {

probing/cli/src/lib.rs

@@ -7,12 +7,23 @@
 use anyhow::Result;
 use clap::Parser;
 use env_logger::Env;
+use std::time::Duration;
+use tokio::time::timeout;
 
 const ENV_PROBING_LOGLEVEL: &str = "PROBING_LOGLEVEL";
 
 /// Main entry point for the CLI, can be called from Python or as a binary
-#[tokio::main]
 pub async fn cli_main(args: Vec<String>) -> Result<()> {
     let _ = env_logger::try_init_from_env(Env::new().filter(ENV_PROBING_LOGLEVEL));
-    cli::Cli::parse_from(args).run().await
+
+    let mut cli =  cli::Cli::parse_from(args);
+
+    if cli.should_timeout() {
+        match timeout(Duration::from_secs(10), cli.run()).await {
+            Ok(result) => result,
+            Err(_) => Err(anyhow::anyhow!("Cli Command Timeout reached")),
+        }
+    } else { 
+        cli.run().await
+    }
 }

probing/cli/src/main.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
 use probing_cli::cli_main;
 
-fn main() -> Result<()> {
+#[tokio::main]
+async fn main() -> Result<()> {
     let args: Vec<String> = std::env::args().collect();
     // cli_main already uses #[tokio::main], so it handles async execution internally
-    cli_main(args)
+    cli_main(args).await
 }

probing/extensions/python/src/features/python_api.rs

@@ -42,7 +42,12 @@ pub fn query_json(_py: Python, sql: String) -> PyResult<String> {
 
 #[pyfunction]
 pub fn cli_main(_py: Python, args: Vec<String>) -> PyResult<()> {
-    if let Err(e) = cli_main_impl(args) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?;
+
+    if let Err(e) = runtime.block_on(cli_main_impl(args)) {
         return Err(PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(
             e.to_string(),
         ));