Call kic-discover-visa if conditions are right

kic-discover/Cargo.toml

@@ -32,4 +32,8 @@ tokio = { version = "1.36.0", features = ["full"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tsp-toolkit-kic-lib = { workspace = true }
+windows-sys = { version = "0.52.0", features = [
+    "Win32_System_Console",
+    "Win32_Foundation",
+] }
 

kic-discover/src/main.rs

@@ -22,6 +22,9 @@ use clap::{command, Args, Command, FromArgMatches, Parser, Subcommand};
 
 use kic_discover::DISC_INSTRUMENTS;
 
+mod process;
+use crate::process::Process;
+
 #[derive(Debug, Parser)]
 #[command(author, version, about, long_about = None)]
 struct Cli {
@@ -216,6 +219,32 @@ fn start_logger(
 #[tokio::main]
 #[instrument]
 async fn main() -> anyhow::Result<()> {
+    let parent_dir: Option<std::path::PathBuf> = std::env::current_exe().map_or(None, |path| {
+        path.canonicalize()
+            .expect("should have canonicalized path")
+            .parent()
+            .map(std::convert::Into::into)
+    });
+
+    if tsp_toolkit_kic_lib::is_visa_installed() {
+        #[cfg(target_os = "windows")]
+        let kic_discover_visa_exe: Option<std::path::PathBuf> = parent_dir.clone().map(|d| d.join("kic-discover-visa.exe"));
+
+        #[cfg(target_family = "unix")]
+        let kic_discover_visa_exe: Option<std::path::PathBuf> = parent_dir.clone().map(|d| d.join("kic-discover-visa"));
+
+        if let Some(kv) = kic_discover_visa_exe {
+            if kv.exists() {
+                Process::new(kv.clone(), std::env::args().skip(1))
+                    .exec_replace()
+                    .context(format!(
+                        "{} should have been launched because VISA was detected",
+                        kv.display(),
+                    ))?;
+                return Ok(());
+            }
+        }
+    }
     let cmd = command!()
         .propagate_version(true)
         .subcommand_required(true)

kic-discover/src/process.rs

@@ -0,0 +1,87 @@
+use std::{io::ErrorKind, path::PathBuf};
+
+#[derive(Debug)]
+pub struct Process {
+    path: PathBuf,
+    args: Vec<String>,
+}
+impl Process {
+    pub fn new<I>(path: PathBuf, args: I) -> Self
+    where
+        I: IntoIterator,
+        I::Item: AsRef<str>,
+    {
+        Self {
+            path,
+            args: args.into_iter().map(|s| s.as_ref().to_string()).collect(),
+        }
+    }
+
+    pub fn exec_replace(self) -> anyhow::Result<()> {
+        imp::exec_replace(&self)
+    }
+
+    #[cfg_attr(unix, allow(dead_code))]
+    pub fn exec(&self) -> anyhow::Result<()> {
+        let exit = std::process::Command::new(&self.path)
+            .args(&self.args)
+            .spawn()?
+            .wait()?;
+        if exit.success() {
+            Ok(())
+        } else {
+            Err(std::io::Error::new(
+                ErrorKind::Other,
+                format!(
+                    "child process did not exit successfully: {}",
+                    self.path.display()
+                ),
+            )
+            .into())
+        }
+    }
+}
+
+#[cfg(windows)]
+mod imp {
+    use std::io::ErrorKind;
+
+    use super::Process;
+    use windows_sys::Win32::{
+        Foundation::{BOOL, FALSE, TRUE},
+        System::Console::SetConsoleCtrlHandler,
+    };
+
+    #[allow(clippy::missing_const_for_fn)] // This lint seems to be broken for this specific case
+    unsafe extern "system" fn ctrlc_handler(_: u32) -> BOOL {
+        TRUE
+    }
+
+    pub(super) fn exec_replace(process: &Process) -> anyhow::Result<()> {
+        //Safety: This is an external handler that calls into the windows API. It is
+        //        expected to be safe.
+        unsafe {
+            if SetConsoleCtrlHandler(Some(ctrlc_handler), TRUE) == FALSE {
+                return Err(std::io::Error::new(
+                    ErrorKind::Other,
+                    "Unable to set Ctrl+C Handler".to_string(),
+                )
+                .into());
+            }
+        }
+
+        process.exec()
+    }
+}
+
+#[cfg(unix)]
+mod imp {
+    use crate::Process;
+    use std::os::unix::process::CommandExt;
+
+    pub(super) fn exec_replace(process: &Process) -> anyhow::Result<()> {
+        let mut command = std::process::Command::new(&process.path);
+        command.args(&process.args);
+        Err(command.exec().into()) // Exec replaces the current application's program memory, therefore execution will
+    }
+}