fix(inspector): inherit stdio for inspect runner

Author: eboody

cargo-statum-graph/src/lib.rs

@@ -5,7 +5,7 @@ use std::fs;
 use std::io;
 use std::path::Component;
 use std::path::{Path, PathBuf};
-use std::process::{Command, ExitStatus};
+use std::process::{Command, ExitStatus, Stdio};
 
 use cargo_metadata::{Metadata, MetadataCommand, Package, PackageId};
 use statum_graph::CodebaseDoc;
@@ -69,6 +69,7 @@ pub enum Error {
         manifest_path: PathBuf,
         status: ExitStatus,
         details: Option<String>,
+        diagnostics_reported: bool,
     },
 }
 
@@ -137,6 +138,7 @@ impl fmt::Display for Error {
                 manifest_path,
                 status,
                 details,
+                diagnostics_reported: _,
             } => match details {
                 Some(details) => write!(
                     formatter,
@@ -153,6 +155,18 @@ impl fmt::Display for Error {
     }
 }
 
+impl Error {
+    pub fn diagnostics_reported(&self) -> bool {
+        matches!(
+            self,
+            Self::RunnerFailed {
+                diagnostics_reported: true,
+                ..
+            }
+        )
+    }
+}
+
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
@@ -191,6 +205,7 @@ pub fn run(options: Options) -> Result<Vec<PathBuf>, Error> {
         temp_dir.path().join("Cargo.toml"),
         &prepared.input.manifest_path,
         "codebase export",
+        RunnerStdio::Captured,
     )?;
 
     Ok(bundle_paths(&out_dir, &options.stem))
@@ -216,6 +231,7 @@ pub fn inspect(options: InspectOptions) -> Result<(), Error> {
         temp_dir.path().join("Cargo.toml"),
         &prepared.input.manifest_path,
         "inspect session",
+        RunnerStdio::Inherited,
     )
 }
 
@@ -590,28 +606,59 @@ fn run_runner(
     runner_manifest_path: PathBuf,
     target_manifest_path: &Path,
     operation: &'static str,
+    stdio: RunnerStdio,
 ) -> Result<(), Error> {
-    let output = Command::new("cargo")
+    let mut command = Command::new("cargo");
+    command
         .arg("run")
         .arg("--quiet")
         .arg("--manifest-path")
-        .arg(&runner_manifest_path)
-        .output()
-        .map_err(|source| Error::Io {
-            action: "run generated cargo runner",
-            path: runner_manifest_path.clone(),
-            source,
-        })?;
-
-    if output.status.success() {
-        Ok(())
-    } else {
-        Err(Error::RunnerFailed {
-            operation,
-            manifest_path: target_manifest_path.to_path_buf(),
-            status: output.status,
-            details: normalize_runner_failure_details(&output.stderr, &output.stdout),
-        })
+        .arg(&runner_manifest_path);
+
+    match stdio {
+        RunnerStdio::Captured => {
+            let output = command.output().map_err(|source| Error::Io {
+                action: "run generated cargo runner",
+                path: runner_manifest_path.clone(),
+                source,
+            })?;
+
+            if output.status.success() {
+                Ok(())
+            } else {
+                Err(Error::RunnerFailed {
+                    operation,
+                    manifest_path: target_manifest_path.to_path_buf(),
+                    status: output.status,
+                    details: normalize_runner_failure_details(&output.stderr, &output.stdout),
+                    diagnostics_reported: false,
+                })
+            }
+        }
+        RunnerStdio::Inherited => {
+            let status = command
+                .stdin(Stdio::inherit())
+                .stdout(Stdio::inherit())
+                .stderr(Stdio::inherit())
+                .status()
+                .map_err(|source| Error::Io {
+                    action: "run generated cargo runner",
+                    path: runner_manifest_path.clone(),
+                    source,
+                })?;
+
+            if status.success() {
+                Ok(())
+            } else {
+                Err(Error::RunnerFailed {
+                    operation,
+                    manifest_path: target_manifest_path.to_path_buf(),
+                    status,
+                    details: None,
+                    diagnostics_reported: true,
+                })
+            }
+        }
     }
 }
 
@@ -784,6 +831,12 @@ struct PreparedRun {
     patch_root: Option<PathBuf>,
 }
 
+#[derive(Clone, Copy)]
+enum RunnerStdio {
+    Captured,
+    Inherited,
+}
+
 #[derive(Clone, Copy)]
 enum RunnerMode<'a> {
     Export { out_dir: &'a Path, stem: &'a str },

cargo-statum-graph/src/main.rs

@@ -50,7 +50,9 @@ fn main() -> ExitCode {
     match run_main() {
         Ok(()) => ExitCode::SUCCESS,
         Err(error) => {
-            eprintln!("{error}");
+            if !error.diagnostics_reported() {
+                eprintln!("{error}");
+            }
             ExitCode::FAILURE
         }
     }

cargo-statum-graph/tests/cli.rs

@@ -150,8 +150,8 @@ fn inspect_command_fails_closed_without_an_interactive_terminal() {
 
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("inspect session"),
-        "stderr should identify the inspect path, got: {stderr}"
+        !stderr.contains("inspect session"),
+        "stderr should not be double-wrapped by the parent CLI, got: {stderr}"
     );
     assert!(
         stderr.contains("requires an interactive terminal on stdin and stdout"),