chore: extract ACP stdio transport pre-patch

Extracts independently-mergable fixes from the ongoing ACP work
(tailcallhq#2858) that can land on main immediately.

Three classes of fix:

1. stdin pre-read encapsulation (cli.rs, main.rs)
   Add Cli::uses_stdin() method that centralizes the decision of which
   subcommands own stdin. Subcommands opt in via uses_stdin() rather
   than having the startup pipeline guess from a hardcoded exclusion
   list. This makes it easy to add new stdin-consuming subcommands
   (e.g. an ACP stdio server) without touching the startup logic.

2. Tool output leaking to stdout (context.rs, tool_executor.rs)
   Shell tool execution streamed raw output to io::stdout(), corrupting
   the ACP JSON-RPC stream. Add silent: bool field on ToolCallContext
   (the correct home for per-invocation runtime flags). Default false;
   ACP sets .silent(true) to route output to io::sink() instead.

3. Stderr vs stdout discipline (main.rs, sandbox.rs)
   Panic hook and worktree status messages used println! which writes
   to stdout. Changed to eprintln! (stderr) to avoid contaminating
   structured transport channels.

Signed-off-by: ssfdust <ssfdust@gmail.com>
Co-authored-by: ForgeCode <noreply@forgecode.dev>
Co-authored-by: DeepSeek <deepseek-ai@deepseek.com>

Author: 3 people

crates/forge_app/src/orch.rs

@@ -262,6 +262,9 @@ impl<S: AgentService + EnvironmentInfra<Config = forge_config::ForgeConfig>> Orc
 
         // Retrieve the number of requests allowed per tick.
         let max_requests_per_turn = self.agent.max_requests_per_turn;
+        // TODO(acp): when running in ACP stdio mode, chain `.silent(true)`
+        // so that shell tool output is suppressed on stdout (see
+        // ToolCallContext and tool_executor).
         let tool_context =
             ToolCallContext::new(self.conversation.metrics.clone()).sender(self.sender.clone());
 

crates/forge_app/src/tool_executor.rs

@@ -277,7 +277,7 @@ impl<
                         input.command.clone(),
                         PathBuf::from(normalized_cwd),
                         input.keep_ansi,
-                        false,
+                        context.silent,
                         input.env.clone(),
                         input.description.clone(),
                     )

crates/forge_domain/src/tools/call/context.rs

@@ -9,12 +9,17 @@ use crate::{ArcSender, ChatResponse, Metrics, TitleFormat, Todo, TodoItem};
 pub struct ToolCallContext {
     sender: Option<ArcSender>,
     metrics: Arc<Mutex<Metrics>>,
+    /// When set to true, shell tool output is streamed to io::sink() instead
+    /// of io::stdout() to avoid contaminating the ACP JSON-RPC transport
+    /// channel. The field is intentionally NOT in ForgeConfig — it is a
+    /// per-invocation runtime behaviour flag, not persisted state.
+    pub silent: bool,
 }
 
 impl ToolCallContext {
     /// Creates a new ToolCallContext with default values
     pub fn new(metrics: Metrics) -> Self {
-        Self { sender: None, metrics: Arc::new(Mutex::new(metrics)) }
+        Self { sender: None, metrics: Arc::new(Mutex::new(metrics)), silent: false }
     }
 
     /// Send a message through the sender if available

crates/forge_infra/src/executor.rs

@@ -108,7 +108,13 @@ impl ForgeCommandExecutorService {
         let mut stdout_pipe = child.stdout.take();
         let mut stderr_pipe = child.stderr.take();
 
-        // Stream the output of the command to stdout and stderr concurrently
+        // Stream the output of the command to stdout and stderr concurrently.
+        //
+        // TODO(acp): when `silent` is true (ACP stdio mode), output is
+        // streamed to io::sink() so that raw command output does not
+        // contaminate the ACP JSON-RPC transport on stdout. The captured
+        // output is still returned via CommandOutput for the ACP
+        // notification channel.
         let (status, stdout_buffer, stderr_buffer) = if silent {
             tokio::try_join!(
                 child.wait(),

crates/forge_main/src/cli.rs

@@ -75,6 +75,15 @@ impl Cli {
     pub fn is_interactive(&self) -> bool {
         self.prompt.is_none() && self.piped_input.is_none() && self.subcommands.is_none()
     }
+
+    /// Checks if the subcommand owns stdin and should skip the piped-input
+    /// pre-read.
+    ///
+    /// Commands like `forge select` interactively read from stdin and would
+    /// hang if the startup pipeline consumed stdin first.
+    pub fn uses_stdin(&self) -> bool {
+        matches!(&self.subcommands, Some(TopLevelCommand::Select(_)))
+    }
 }
 
 #[derive(Subcommand, Debug, Clone)]

crates/forge_main/src/main.rs

@@ -7,7 +7,7 @@ use clap::Parser;
 use forge_api::ForgeAPI;
 use forge_config::ForgeConfig;
 use forge_domain::TitleFormat;
-use forge_main::{Cli, Sandbox, TitleDisplayExt, TopLevelCommand, UI, tracker};
+use forge_main::{Cli, Sandbox, TitleDisplayExt, UI, tracker};
 
 /// Enables ENABLE_VIRTUAL_TERMINAL_PROCESSING on the stdout console handle.
 ///
@@ -82,18 +82,17 @@ async fn run() -> Result<()> {
             "Unexpected error occurred".to_string()
         };
 
-        println!("{}", TitleFormat::error(message.to_string()).display());
+        eprintln!("{}", TitleFormat::error(message.to_string()).display());
         tracker::error_blocking(message);
         std::process::exit(1);
     }));
 
     // Initialize and run the UI
     let mut cli = Cli::parse();
 
-    // Check if there's piped input, but skip for `forge select` since that
-    // command uses stdin for its item list.
-    let is_select = matches!(cli.subcommands, Some(TopLevelCommand::Select(_)));
-    if !is_select && !std::io::stdin().is_terminal() {
+    // Check if there's piped input, but skip for commands that use stdin
+    // for their own protocol (e.g. `forge select`).
+    if !cli.uses_stdin() && !std::io::stdin().is_terminal() {
         let mut stdin_content = String::new();
         std::io::stdin().read_to_string(&mut stdin_content)?;
         let trimmed_content = stdin_content.trim();

crates/forge_main/src/sandbox.rs

@@ -69,7 +69,7 @@ impl<'a> Sandbox<'a> {
                     .context("Failed to check if target directory is a git worktree")?;
 
                 if worktree_check.status.success() {
-                    println!(
+                    eprintln!(
                         "{}",
                         TitleFormat::info("Worktree [Reused]")
                             .sub_title(worktree_path.display().to_string())
@@ -125,7 +125,7 @@ impl<'a> Sandbox<'a> {
             bail!("Failed to create git worktree: {stderr}");
         }
 
-        println!(
+        eprintln!(
             "{}",
             TitleFormat::info("Worktree [Created]")
                 .sub_title(worktree_path.display().to_string())