path: root/makima/src/daemon/process/claude.rs

//! Claude Code process management.

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::Arc;

use futures::Stream;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::process::{Child, ChildStdin, Command};
use tokio::sync::{mpsc, Mutex};

use super::claude_protocol::ClaudeInputMessage;
use crate::daemon::config::BubblewrapConfig;

/// Errors that can occur during Claude process management.
#[derive(Debug, thiserror::Error)]
pub enum ClaudeProcessError {
    #[error("Failed to spawn Claude process: {0}")]
    SpawnFailed(#[from] std::io::Error),

    #[error("Claude command not found: {0}")]
    CommandNotFound(String),

    #[error("Process already exited")]
    AlreadyExited,

    #[error("Failed to read output: {0}")]
    OutputRead(String),

    #[error("Bubblewrap (bwrap) not found. Install bubblewrap or disable the --bubblewrap flag.")]
    BubblewrapNotFound,
}

/// A line of output from Claude Code.
#[derive(Debug, Clone)]
pub struct OutputLine {
    /// The raw content of the line.
    pub content: String,
    /// Whether this is from stdout (true) or stderr (false).
    pub is_stdout: bool,
    /// Parsed JSON type if available (e.g., "system", "assistant", "result").
    pub json_type: Option<String>,
}

impl OutputLine {
    /// Create a new stdout output line.
    pub fn stdout(content: String) -> Self {
        let json_type = extract_json_type(&content);
        Self {
            content,
            is_stdout: true,
            json_type,
        }
    }

    /// Create a new stderr output line.
    pub fn stderr(content: String) -> Self {
        Self {
            content,
            is_stdout: false,
            json_type: None,
        }
    }
}

/// Extract the "type" field from a JSON line if present.
fn extract_json_type(line: &str) -> Option<String> {
    // Quick check for JSON
    if !line.starts_with('{') {
        return None;
    }

    // Try to parse and extract type
    if let Ok(json) = serde_json::from_str::<serde_json::Value>(line) {
        json.get("type")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string())
    } else {
        None
    }
}

/// Handle to a running Claude Code process.
pub struct ClaudeProcess {
    /// The child process.
    child: Child,
    /// Receiver for output lines.
    output_rx: mpsc::Receiver<OutputLine>,
    /// Stdin handle for sending input to the process (thread-safe).
    stdin: Arc<Mutex<Option<ChildStdin>>>,
}

impl ClaudeProcess {
    /// Wait for the process to exit and return the exit code.
    pub async fn wait(&mut self) -> Result<i64, ClaudeProcessError> {
        let status = self.child.wait().await?;
        Ok(status.code().unwrap_or(-1) as i64)
    }

    /// Check if the process has exited.
    pub fn try_wait(&mut self) -> Result<Option<i64>, ClaudeProcessError> {
        match self.child.try_wait()? {
            Some(status) => Ok(Some(status.code().unwrap_or(-1) as i64)),
            None => Ok(None),
        }
    }

    /// Kill the process (SIGKILL).
    pub async fn kill(&mut self) -> Result<(), ClaudeProcessError> {
        self.child.kill().await?;
        Ok(())
    }

    /// Get the process ID, if the process is still running.
    pub fn id(&self) -> Option<u32> {
        self.child.id()
    }

    /// Send SIGTERM to gracefully terminate the process and all its children (Unix only).
    /// Returns Ok(true) if signal was sent, Ok(false) if process already exited.
    /// Sends signal to the entire process group (negative PID) to kill all children.
    #[cfg(unix)]
    pub fn terminate(&self) -> Result<bool, ClaudeProcessError> {
        use nix::sys::signal::{killpg, Signal};
        use nix::unistd::Pid;

        if let Some(pid) = self.child.id() {
            // Kill the entire process group (the process is its own group leader)
            match killpg(Pid::from_raw(pid as i32), Signal::SIGTERM) {
                Ok(()) => Ok(true),
                Err(nix::errno::Errno::ESRCH) => Ok(false), // Process group doesn't exist
                Err(e) => Err(ClaudeProcessError::OutputRead(format!(
                    "Failed to send SIGTERM to process group: {}",
                    e
                ))),
            }
        } else {
            Ok(false) // Process already exited
        }
    }

    /// Send SIGTERM to gracefully terminate the process (no-op on non-Unix).
    #[cfg(not(unix))]
    pub fn terminate(&self) -> Result<bool, ClaudeProcessError> {
        // On non-Unix platforms, fall back to kill
        Ok(false)
    }

    /// Get the next output line, if available.
    pub async fn next_output(&mut self) -> Option<OutputLine> {
        self.output_rx.recv().await
    }

    /// Send a raw message to the process via stdin.
    ///
    /// This can be used to provide input when Claude Code is waiting for user input.
    pub async fn send_input(&self, message: &str) -> Result<(), ClaudeProcessError> {
        let mut stdin_guard = self.stdin.lock().await;
        if let Some(ref mut stdin) = *stdin_guard {
            stdin
                .write_all(message.as_bytes())
                .await
                .map_err(|e| ClaudeProcessError::OutputRead(format!("Failed to write to stdin: {}", e)))?;
            stdin
                .write_all(b"\n")
                .await
                .map_err(|e| ClaudeProcessError::OutputRead(format!("Failed to write newline: {}", e)))?;
            stdin
                .flush()
                .await
                .map_err(|e| ClaudeProcessError::OutputRead(format!("Failed to flush stdin: {}", e)))?;
            Ok(())
        } else {
            Err(ClaudeProcessError::OutputRead("Stdin not available".to_string()))
        }
    }

    /// Send a user message to the process via stdin using JSON protocol.
    ///
    /// This is the preferred method when using `--input-format=stream-json`.
    /// The message is serialized as JSON and sent as a single line.
    pub async fn send_user_message(&self, content: &str) -> Result<(), ClaudeProcessError> {
        let message = ClaudeInputMessage::user(content);
        let json_line = message.to_json_line().map_err(|e| {
            ClaudeProcessError::OutputRead(format!("Failed to serialize message: {}", e))
        })?;

        tracing::debug!(content_len = content.len(), "Sending user message to Claude process");

        let mut stdin_guard = self.stdin.lock().await;
        if let Some(ref mut stdin) = *stdin_guard {
            stdin
                .write_all(json_line.as_bytes())
                .await
                .map_err(|e| ClaudeProcessError::OutputRead(format!("Failed to write to stdin: {}", e)))?;
            stdin
                .flush()
                .await
                .map_err(|e| ClaudeProcessError::OutputRead(format!("Failed to flush stdin: {}", e)))?;
            Ok(())
        } else {
            Err(ClaudeProcessError::OutputRead("Stdin not available".to_string()))
        }
    }

    /// Get a clone of the stdin handle for external use.
    pub fn stdin_handle(&self) -> Arc<Mutex<Option<ChildStdin>>> {
        Arc::clone(&self.stdin)
    }

    /// Close stdin, signaling EOF to the process.
    pub async fn close_stdin(&self) -> Result<(), ClaudeProcessError> {
        let mut stdin_guard = self.stdin.lock().await;
        if let Some(mut stdin) = stdin_guard.take() {
            let _ = stdin.shutdown().await;
        }
        Ok(())
    }

    /// Convert to a stream of output lines.
    pub fn into_stream(self) -> impl Stream<Item = OutputLine> {
        futures::stream::unfold(self.output_rx, |mut rx| async move {
            rx.recv().await.map(|line| (line, rx))
        })
    }
}

/// Manages Claude Code process spawning.
pub struct ProcessManager {
    /// Path to the claude command.
    claude_command: String,
    /// Additional arguments to pass to Claude Code (after defaults).
    claude_args: Vec<String>,
    /// Arguments to pass before defaults.
    claude_pre_args: Vec<String>,
    /// Whether to enable Claude's permission system (skip --dangerously-skip-permissions).
    enable_permissions: bool,
    /// Whether to disable verbose output.
    disable_verbose: bool,
    /// Default environment variables to pass.
    default_env: HashMap<String, String>,
    /// Bubblewrap sandbox configuration.
    bubblewrap: Option<BubblewrapConfig>,
}

impl Default for ProcessManager {
    fn default() -> Self {
        Self::new()
    }
}

impl ProcessManager {
    /// Create a new ProcessManager with default settings.
    pub fn new() -> Self {
        Self {
            claude_command: "claude".to_string(),
            claude_args: Vec::new(),
            claude_pre_args: Vec::new(),
            enable_permissions: false,
            disable_verbose: false,
            default_env: HashMap::new(),
            bubblewrap: None,
        }
    }

    /// Create a ProcessManager with a custom claude command path.
    pub fn with_command(command: String) -> Self {
        Self {
            claude_command: command,
            claude_args: Vec::new(),
            claude_pre_args: Vec::new(),
            enable_permissions: false,
            disable_verbose: false,
            default_env: HashMap::new(),
            bubblewrap: None,
        }
    }

    /// Set additional arguments to pass after default arguments.
    pub fn with_args(mut self, args: Vec<String>) -> Self {
        self.claude_args = args;
        self
    }

    /// Set arguments to pass before default arguments.
    pub fn with_pre_args(mut self, args: Vec<String>) -> Self {
        self.claude_pre_args = args;
        self
    }

    /// Enable Claude's permission system (don't pass --dangerously-skip-permissions).
    pub fn with_permissions_enabled(mut self, enabled: bool) -> Self {
        self.enable_permissions = enabled;
        self
    }

    /// Disable verbose output.
    pub fn with_verbose_disabled(mut self, disabled: bool) -> Self {
        self.disable_verbose = disabled;
        self
    }

    /// Add default environment variables.
    pub fn with_env(mut self, env: HashMap<String, String>) -> Self {
        self.default_env = env;
        self
    }

    /// Configure bubblewrap sandboxing.
    ///
    /// When enabled, Claude processes will be spawned inside a bubblewrap sandbox
    /// with filesystem isolation.
    pub fn with_bubblewrap(mut self, config: Option<BubblewrapConfig>) -> Self {
        self.bubblewrap = config;
        self
    }

    /// Get the claude command path.
    pub fn claude_command(&self) -> &str {
        &self.claude_command
    }

    /// Check if bubblewrap (bwrap) is available on the system.
    ///
    /// Returns the bwrap version string if available.
    pub async fn check_bwrap_available(&self) -> Result<String, ClaudeProcessError> {
        let bwrap_cmd = self
            .bubblewrap
            .as_ref()
            .map(|c| c.bwrap_command.as_str())
            .unwrap_or("bwrap");

        let output = Command::new(bwrap_cmd)
            .arg("--version")
            .output()
            .await
            .map_err(|e| {
                if e.kind() == std::io::ErrorKind::NotFound {
                    ClaudeProcessError::BubblewrapNotFound
                } else {
                    ClaudeProcessError::SpawnFailed(e)
                }
            })?;

        if output.status.success() {
            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
        } else {
            Err(ClaudeProcessError::BubblewrapNotFound)
        }
    }

    /// Build bwrap command arguments for sandboxing.
    ///
    /// Returns a tuple of (bwrap_command, bwrap_args) where bwrap_args includes
    /// all the sandbox flags followed by "--" and the actual command to run.
    fn build_bwrap_args(
        &self,
        working_dir: &Path,
        claude_command: &str,
        claude_args: &[String],
        config: &BubblewrapConfig,
    ) -> (String, Vec<String>) {
        let mut args = Vec::new();

        // Unshare all namespaces except user (for unprivileged use)
        args.push("--unshare-all".to_string());

        // Share network if enabled (needed for API calls)
        if config.network {
            args.push("--share-net".to_string());
        }

        // Safety flags
        args.push("--die-with-parent".to_string());
        args.push("--new-session".to_string());

        // Bind root filesystem read-only
        args.push("--ro-bind".to_string());
        args.push("/".to_string());
        args.push("/".to_string());

        // Mount fresh /dev
        args.push("--dev".to_string());
        args.push("/dev".to_string());

        // Mount fresh /proc
        args.push("--proc".to_string());
        args.push("/proc".to_string());

        // Fresh /tmp
        args.push("--tmpfs".to_string());
        args.push("/tmp".to_string());

        // Bind working directory (worktree) read-write
        let working_dir_str = working_dir.to_string_lossy().to_string();
        args.push("--bind".to_string());
        args.push(working_dir_str.clone());
        args.push(working_dir_str);

        // Bind ~/.claude read-write if it exists (for Claude config)
        if let Ok(home) = std::env::var("HOME") {
            let claude_config_dir = PathBuf::from(&home).join(".claude");
            if claude_config_dir.exists() {
                let claude_config_str = claude_config_dir.to_string_lossy().to_string();
                args.push("--bind".to_string());
                args.push(claude_config_str.clone());
                args.push(claude_config_str);
            }

            // Also bind ~/.config/claude if it exists (alternative config location)
            let claude_config_alt = PathBuf::from(&home).join(".config").join("claude");
            if claude_config_alt.exists() {
                let config_str = claude_config_alt.to_string_lossy().to_string();
                args.push("--bind".to_string());
                args.push(config_str.clone());
                args.push(config_str);
            }
        }

        // Additional read-only binds from config
        for path in &config.ro_bind {
            if path.exists() {
                let path_str = path.to_string_lossy().to_string();
                args.push("--ro-bind".to_string());
                args.push(path_str.clone());
                args.push(path_str);
            }
        }

        // Additional read-write binds from config
        for path in &config.rw_bind {
            if path.exists() {
                let path_str = path.to_string_lossy().to_string();
                args.push("--bind".to_string());
                args.push(path_str.clone());
                args.push(path_str);
            }
        }

        // Separator before the actual command
        args.push("--".to_string());

        // Add the claude command and its arguments
        args.push(claude_command.to_string());
        args.extend(claude_args.iter().cloned());

        (config.bwrap_command.clone(), args)
    }

    /// Spawn a Claude Code process to execute a plan.
    ///
    /// The process runs in the specified working directory with stream-json output format.
    /// If `system_prompt` is provided, it will be passed via --system-prompt flag.
    pub async fn spawn(
        &self,
        working_dir: &Path,
        plan: &str,
        extra_env: Option<HashMap<String, String>>,
    ) -> Result<ClaudeProcess, ClaudeProcessError> {
        self.spawn_with_system_prompt(working_dir, plan, extra_env, None).await
    }

    /// Spawn a Claude Code process with an optional system prompt.
    ///
    /// The process runs in the specified working directory with stream-json output format.
    /// If `system_prompt` is provided, it will be passed via --system-prompt flag as
    /// behavioral constraints that Claude will treat as system-level instructions.
    pub async fn spawn_with_system_prompt(
        &self,
        working_dir: &Path,
        plan: &str,
        extra_env: Option<HashMap<String, String>>,
        system_prompt: Option<&str>,
    ) -> Result<ClaudeProcess, ClaudeProcessError> {
        // Check if bubblewrap is enabled and available
        let use_bubblewrap = if let Some(ref bwrap_config) = self.bubblewrap {
            if bwrap_config.enabled {
                // Verify bwrap is available before proceeding
                self.check_bwrap_available().await?;
                true
            } else {
                false
            }
        } else {
            false
        };

        tracing::info!(
            working_dir = %working_dir.display(),
            plan_len = plan.len(),
            plan_preview = %if plan.len() > 200 { &plan[..200] } else { plan },
            has_system_prompt = system_prompt.is_some(),
            bubblewrap_enabled = use_bubblewrap,
            "Spawning Claude Code process"
        );

        // Verify working directory exists
        if !working_dir.exists() {
            tracing::error!(working_dir = %working_dir.display(), "Working directory does not exist!");
            return Err(ClaudeProcessError::SpawnFailed(std::io::Error::new(
                std::io::ErrorKind::NotFound,
                format!("Working directory does not exist: {}", working_dir.display()),
            )));
        }

        // Build environment
        let mut env = self.default_env.clone();
        if let Some(extra) = extra_env {
            env.extend(extra);
        }

        // Load OAuth token from disk and set as env var if not already provided.
        // This allows processes to authenticate using tokens saved by the reauth flow.
        // The token is loaded fresh each time (not cached) so newly saved tokens are picked up.
        if !env.contains_key("CLAUDE_CODE_OAUTH_TOKEN") {
            if let Some(token) = crate::daemon::task::manager::load_oauth_token() {
                tracing::debug!("Setting CLAUDE_CODE_OAUTH_TOKEN from saved token file");
                env.insert("CLAUDE_CODE_OAUTH_TOKEN".to_string(), token);
            }
        }

        // Build Claude arguments list
        let mut claude_args = Vec::new();

        // Pre-args (before defaults)
        claude_args.extend(self.claude_pre_args.clone());

        // Required arguments for stream-json protocol
        claude_args.push("--output-format=stream-json".to_string());
        claude_args.push("--input-format=stream-json".to_string());

        // Optional default arguments
        if !self.disable_verbose {
            claude_args.push("--verbose".to_string());
        }
        if !self.enable_permissions {
            claude_args.push("--dangerously-skip-permissions".to_string());
        }

        // System prompt - passed via --system-prompt flag for system-level constraints
        if let Some(prompt) = system_prompt {
            claude_args.push("--system-prompt".to_string());
            claude_args.push(prompt.to_string());
        }

        // Additional user-configured arguments
        claude_args.extend(self.claude_args.clone());

        // Determine the actual command and arguments to spawn
        let (command, args) = if use_bubblewrap {
            let bwrap_config = self.bubblewrap.as_ref().unwrap();
            let (bwrap_cmd, bwrap_args) =
                self.build_bwrap_args(working_dir, &self.claude_command, &claude_args, bwrap_config);
            tracing::info!(
                bwrap_command = %bwrap_cmd,
                bwrap_args_count = bwrap_args.len(),
                "Running Claude in bubblewrap sandbox"
            );
            tracing::debug!(bwrap_args = ?bwrap_args, "Bubblewrap arguments");
            (bwrap_cmd, bwrap_args)
        } else {
            tracing::debug!(args = ?claude_args, "Claude command arguments");
            (self.claude_command.clone(), claude_args)
        };

        // Spawn the process in its own process group so we can kill all children
        let mut cmd = Command::new(&command);
        cmd.args(&args)
            .current_dir(working_dir)
            .envs(env)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .kill_on_drop(true);

        // On Unix, create a new process group so we can kill all child processes
        #[cfg(unix)]
        {
            use std::os::unix::process::CommandExt;
            cmd.process_group(0);
        }

        let mut child = cmd.spawn().map_err(|e| {
            if e.kind() == std::io::ErrorKind::NotFound {
                if use_bubblewrap {
                    ClaudeProcessError::BubblewrapNotFound
                } else {
                    ClaudeProcessError::CommandNotFound(self.claude_command.clone())
                }
            } else {
                ClaudeProcessError::SpawnFailed(e)
            }
        })?;

        // Create output channel
        let (tx, rx) = mpsc::channel(1000);

        // Take stdout, stderr, and stdin
        // With --input-format=stream-json, we keep stdin open for sending messages
        let stdin = child.stdin.take();
        let stdin = Arc::new(Mutex::new(stdin));

        let stdout = child.stdout.take().expect("stdout should be piped");
        let stderr = child.stderr.take().expect("stderr should be piped");

        // Spawn task to read stdout
        let tx_stdout = tx.clone();
        tokio::spawn(async move {
            use tokio::io::AsyncReadExt;
            let mut reader = BufReader::new(stdout);
            let mut buffer = vec![0u8; 4096];
            let mut line_buffer = String::new();

            loop {
                // Try to read with a timeout to detect if we're stuck
                match tokio::time::timeout(
                    tokio::time::Duration::from_secs(5),
                    reader.read(&mut buffer)
                ).await {
                    Ok(Ok(0)) => {
                        // EOF
                        tracing::debug!("Claude stdout EOF");
                        // Send any remaining content
                        if !line_buffer.is_empty() {
                            let _ = tx_stdout.send(OutputLine::stdout(line_buffer)).await;
                        }
                        break;
                    }
                    Ok(Ok(n)) => {
                        let chunk = String::from_utf8_lossy(&buffer[..n]);
                        tracing::debug!(bytes = n, chunk_preview = %if chunk.len() > 100 { &chunk[..100] } else { &chunk }, "Got stdout chunk from Claude");

                        // Accumulate into line buffer and emit complete lines
                        line_buffer.push_str(&chunk);
                        while let Some(newline_pos) = line_buffer.find('\n') {
                            let line = line_buffer[..newline_pos].to_string();
                            line_buffer = line_buffer[newline_pos + 1..].to_string();
                            if tx_stdout.send(OutputLine::stdout(line)).await.is_err() {
                                return;
                            }
                        }
                    }
                    Ok(Err(e)) => {
                        tracing::error!(error = %e, "Error reading Claude stdout");
                        break;
                    }
                    Err(_) => {
                        // Timeout - no data for 5 seconds
                        tracing::warn!("No stdout data from Claude for 5 seconds");
                    }
                }
            }
            tracing::debug!("Claude stdout reader task ended");
        });

        // Spawn task to read stderr
        let tx_stderr = tx;
        tokio::spawn(async move {
            let reader = BufReader::new(stderr);
            let mut lines = reader.lines();
            while let Ok(Some(line)) = lines.next_line().await {
                tracing::debug!(line = %line, "Claude stderr");
                if tx_stderr.send(OutputLine::stderr(line)).await.is_err() {
                    break;
                }
            }
            tracing::debug!("Claude stderr reader task ended");
        });

        tracing::info!("Claude Code process spawned successfully");

        let process = ClaudeProcess {
            child,
            output_rx: rx,
            stdin,
        };

        // Send the initial plan as the first user message
        tracing::info!(plan_len = plan.len(), "Sending initial plan to Claude via stdin");
        process.send_user_message(plan).await?;

        Ok(process)
    }

    /// Spawn a Claude Code process in continuation mode.
    ///
    /// This is used for the autonomous loop feature where we need to continue
    /// a previous conversation. The --continue flag tells Claude to resume
    /// from the previous session state.
    pub async fn spawn_continue(
        &self,
        working_dir: &Path,
        continuation_prompt: &str,
        extra_env: Option<HashMap<String, String>>,
        system_prompt: Option<&str>,
    ) -> Result<ClaudeProcess, ClaudeProcessError> {
        tracing::info!(
            working_dir = %working_dir.display(),
            prompt_len = continuation_prompt.len(),
            has_system_prompt = system_prompt.is_some(),
            "Spawning Claude Code process in continuation mode"
        );

        // Verify working directory exists
        if !working_dir.exists() {
            tracing::error!(working_dir = %working_dir.display(), "Working directory does not exist!");
            return Err(ClaudeProcessError::SpawnFailed(std::io::Error::new(
                std::io::ErrorKind::NotFound,
                format!("Working directory does not exist: {}", working_dir.display()),
            )));
        }

        // Build environment
        let mut env = self.default_env.clone();
        if let Some(extra) = extra_env {
            env.extend(extra);
        }

        // Build arguments list
        let mut args = Vec::new();

        // Pre-args (before defaults)
        args.extend(self.claude_pre_args.clone());

        // Required arguments for stream-json protocol
        args.push("--output-format=stream-json".to_string());
        args.push("--input-format=stream-json".to_string());

        // The key flag for continuation mode
        args.push("--continue".to_string());

        // Optional default arguments
        if !self.disable_verbose {
            args.push("--verbose".to_string());
        }
        if !self.enable_permissions {
            args.push("--dangerously-skip-permissions".to_string());
        }

        // System prompt - passed via --system-prompt flag for system-level constraints
        if let Some(prompt) = system_prompt {
            args.push("--system-prompt".to_string());
            args.push(prompt.to_string());
        }

        // Additional user-configured arguments
        args.extend(self.claude_args.clone());

        tracing::debug!(args = ?args, "Claude continue command arguments");

        // Spawn the process in its own process group so we can kill all children
        let mut cmd = Command::new(&self.claude_command);
        cmd.args(&args)
            .current_dir(working_dir)
            .envs(env)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .kill_on_drop(true);

        // On Unix, create a new process group so we can kill all child processes
        #[cfg(unix)]
        {
            use std::os::unix::process::CommandExt;
            cmd.process_group(0);
        }

        let mut child = cmd.spawn().map_err(|e| {
            if e.kind() == std::io::ErrorKind::NotFound {
                ClaudeProcessError::CommandNotFound(self.claude_command.clone())
            } else {
                ClaudeProcessError::SpawnFailed(e)
            }
        })?;

        // Create output channel
        let (tx, rx) = mpsc::channel(1000);

        // Take stdout, stderr, and stdin
        let stdin = child.stdin.take();
        let stdin = Arc::new(Mutex::new(stdin));

        let stdout = child.stdout.take().expect("stdout should be piped");
        let stderr = child.stderr.take().expect("stderr should be piped");

        // Spawn task to read stdout
        let tx_stdout = tx.clone();
        tokio::spawn(async move {
            use tokio::io::AsyncReadExt;
            let mut reader = BufReader::new(stdout);
            let mut buffer = vec![0u8; 4096];
            let mut line_buffer = String::new();

            loop {
                match tokio::time::timeout(
                    tokio::time::Duration::from_secs(5),
                    reader.read(&mut buffer)
                ).await {
                    Ok(Ok(0)) => {
                        tracing::debug!("Claude stdout EOF (continue mode)");
                        if !line_buffer.is_empty() {
                            let _ = tx_stdout.send(OutputLine::stdout(line_buffer)).await;
                        }
                        break;
                    }
                    Ok(Ok(n)) => {
                        let chunk = String::from_utf8_lossy(&buffer[..n]);
                        line_buffer.push_str(&chunk);
                        while let Some(newline_pos) = line_buffer.find('\n') {
                            let line = line_buffer[..newline_pos].to_string();
                            line_buffer = line_buffer[newline_pos + 1..].to_string();
                            if tx_stdout.send(OutputLine::stdout(line)).await.is_err() {
                                return;
                            }
                        }
                    }
                    Ok(Err(e)) => {
                        tracing::error!(error = %e, "Error reading Claude stdout (continue mode)");
                        break;
                    }
                    Err(_) => {
                        tracing::warn!("No stdout data from Claude for 5 seconds (continue mode)");
                    }
                }
            }
            tracing::debug!("Claude stdout reader task ended (continue mode)");
        });

        // Spawn task to read stderr
        let tx_stderr = tx;
        tokio::spawn(async move {
            let reader = BufReader::new(stderr);
            let mut lines = reader.lines();
            while let Ok(Some(line)) = lines.next_line().await {
                tracing::debug!(line = %line, "Claude stderr (continue mode)");
                if tx_stderr.send(OutputLine::stderr(line)).await.is_err() {
                    break;
                }
            }
            tracing::debug!("Claude stderr reader task ended (continue mode)");
        });

        tracing::info!("Claude Code process spawned successfully in continue mode");

        let process = ClaudeProcess {
            child,
            output_rx: rx,
            stdin,
        };

        // Send the continuation prompt as a user message
        tracing::info!(prompt_len = continuation_prompt.len(), "Sending continuation prompt to Claude via stdin");
        process.send_user_message(continuation_prompt).await?;

        Ok(process)
    }

    /// Check if the claude command is available.
    pub async fn check_claude_available(&self) -> Result<String, ClaudeProcessError> {
        let output = Command::new(&self.claude_command)
            .arg("--version")
            .output()
            .await
            .map_err(|e| {
                if e.kind() == std::io::ErrorKind::NotFound {
                    ClaudeProcessError::CommandNotFound(self.claude_command.clone())
                } else {
                    ClaudeProcessError::SpawnFailed(e)
                }
            })?;

        if output.status.success() {
            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
        } else {
            Err(ClaudeProcessError::CommandNotFound(
                self.claude_command.clone(),
            ))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_extract_json_type() {
        assert_eq!(
            extract_json_type(r#"{"type":"system","subtype":"init"}"#),
            Some("system".to_string())
        );
        assert_eq!(
            extract_json_type(r#"{"type":"assistant","message":{}}"#),
            Some("assistant".to_string())
        );
        assert_eq!(extract_json_type("not json"), None);
        assert_eq!(extract_json_type(r#"{"no_type": true}"#), None);
    }

    #[test]
    fn test_output_line_creation() {
        let line = OutputLine::stdout(r#"{"type":"result"}"#.to_string());
        assert!(line.is_stdout);
        assert_eq!(line.json_type, Some("result".to_string()));

        let line = OutputLine::stderr("error message".to_string());
        assert!(!line.is_stdout);
        assert_eq!(line.json_type, None);
    }
}