pub struct Agent {

    pub id: String,

    pub name: String,

    /// Command to run the agent, as found on this system.

    pub command: String,

    /// Args to pass after `command`.

    pub args: Vec<String>,

}

/// Discover all ACP agents in the registry that are also available locally.

        };

        if is_available(&agent, &npm_root, &uv_tools).await {

            let (command, args) = launch_for(&agent);

            found.push(Agent {

                id: agent.id,

                name: agent.name,

                command,

                args,

            });

        }

    }

    false

}

fn launch_for(agent: &RegistryAgent) -> (String, Vec<String>) {

    let Some(dist) = &agent.distribution else {

        return (agent.id.clone(), Vec::new());

    };

    if let Some(binary) = &dist.binary {

        let platform = current_platform();

        if let Some(target) = binary.get(&platform) {

            let name = Path::new(&target.cmd)

                .file_name()

                .and_then(|s| s.to_str())

                .unwrap_or(&target.cmd)

                .to_string();

            let mut args = target.args.clone().unwrap_or_default();

            // ACP mode is the agent's streaming protocol.

            if !args.iter().any(|a| a == "acp") {

                args.push("acp".to_string());

            }

            return (name, args);

        }

    }

    if let Some(npx) = &dist.npx {

        let mut args = vec!["-y".to_string(), npx.package.clone()];

        if let Some(extra) = &npx.args {

            args.extend(extra.iter().cloned());

        }

        if !args.iter().any(|a| a == "acp") {

            args.push("acp".to_string());

        }

        return ("npx".to_string(), args);

    }

    if let Some(uvx) = &dist.uvx {

        let mut args = vec![uvx.package.clone()];

        if let Some(extra) = &uvx.args {

            args.extend(extra.iter().cloned());

        }

        if !args.iter().any(|a| a == "acp") {

            args.push("acp".to_string());

        }

        return ("uvx".to_string(), args);

    }

    (agent.id.clone(), Vec::new())

}

fn current_platform() -> String {

    use std::env::consts::{ARCH, OS};

    let os = match OS {

//! ACP child agent harness for coder-lite.

//!

//! Spawns an ACP-compatible CLI agent over stdio and streams JSON-RPC

//! `session/update` events as they arrive.

use std::path::Path;

use std::process::Stdio;

use std::time::Duration;

use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};

use tokio::process::{ChildStdin, ChildStdout, Command};

#[derive(Debug)]

pub enum AcpFailure {

    Unstartable(String),

    Refused(String),

}

impl std::fmt::Display for AcpFailure {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            AcpFailure::Unstartable(why) => write!(f, "{why}"),

            AcpFailure::Refused(why) => write!(f, "{why}"),

        }

    }

}

#[derive(Debug, Clone)]

pub enum AcpEvent {

    Session { id: String },

    Tool { kind: String, title: String },

    Tokens { input: u64, output: u64 },

    Text { chunk: String },

}

#[derive(Debug, Clone)]

pub struct AcpHarness {

    pub command: String,

    pub args: Vec<String>,

}

impl Default for AcpHarness {

    fn default() -> Self {

        Self {

            command: "devin".to_string(),

            args: vec!["acp".to_string()],

        }

    }

}

const REQUEST_TIMEOUT: Duration = Duration::from_secs(900);

const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(60);

impl AcpHarness {

    pub async fn run<F>(

        &self,

        prompt: &str,

        cwd: &Path,

        mut on_event: F,

    ) -> Result<String, AcpFailure>

    where

        F: FnMut(AcpEvent) + Send,

    {

        let mut child = Command::new(&self.command)

            .args(&self.args)

            .current_dir(cwd)

            .stdin(Stdio::piped())

            .stdout(Stdio::piped())

            .stderr(Stdio::piped())

            .spawn()

            .map_err(|error| {

                AcpFailure::Unstartable(if error.kind() == std::io::ErrorKind::NotFound {

                    format!("the `{}` command is not on PATH", self.command)

                } else {

                    format!("the `{}` command would not start: {error}", self.command)

                })

            })?;

        if let Some(stderr) = child.stderr.take() {

            tokio::spawn(async move {

                let mut lines = BufReader::new(stderr).lines();

                while let Ok(Some(_)) = lines.next_line().await {}

            });

        }

        let stdin = child.stdin.take();

        let stdout = child.stdout.take();

        let (Some(mut stdin), Some(stdout)) = (stdin, stdout) else {

            let _ = child.kill().await;

            return Err(AcpFailure::Refused(

                "the agent's standard streams could not be opened".to_string(),

            ));

        };

        let mut lines = BufReader::new(stdout).lines();

        let outcome = self

            .converse(prompt, cwd, &mut stdin, &mut lines, &mut on_event)

            .await;

        let _ = child.kill().await;

        outcome

    }

    async fn converse<F>(

        &self,

        prompt: &str,

        cwd: &Path,

        stdin: &mut ChildStdin,

        lines: &mut tokio::io::Lines<BufReader<ChildStdout>>,

        on_event: &mut F,

    ) -> Result<String, AcpFailure>

    where

        F: FnMut(AcpEvent) + Send,

    {

        let mut seq: u64 = 0;

        let mut answer = String::new();

        request(

            stdin,

            lines,

            &mut seq,

            "initialize",

            serde_json::json!({

                "protocolVersion": 1,

                "clientCapabilities": {"fs": {"readTextFile": false, "writeTextFile": false}}

            }),

            HANDSHAKE_TIMEOUT,

            &mut answer,

            on_event,

        )

        .await?;

        let opened = request(

            stdin,

            lines,

            &mut seq,

            "session/new",

            serde_json::json!({"cwd": cwd.to_string_lossy(), "mcpServers": []}),

            REQUEST_TIMEOUT,

            &mut answer,

            on_event,

        )

        .await?;

        let session_id = opened

            .get("sessionId")

            .and_then(|v| v.as_str())

            .ok_or_else(|| AcpFailure::Refused("the agent opened no session".to_string()))?

            .to_string();

        on_event(AcpEvent::Session {

            id: session_id.clone(),

        });

        request(

            stdin,

            lines,

            &mut seq,

            "session/prompt",

            serde_json::json!({

                "sessionId": session_id,

                "prompt": [{"type": "text", "text": prompt}]

            }),

            REQUEST_TIMEOUT,

            &mut answer,

            on_event,

        )

        .await?;

        Ok(answer.trim().to_string())

    }

}

#[allow(clippy::too_many_arguments)]

async fn request<F>(

    stdin: &mut ChildStdin,

    lines: &mut tokio::io::Lines<BufReader<ChildStdout>>,

    seq: &mut u64,

    method: &str,

    params: serde_json::Value,

    limit: Duration,

    answer: &mut String,

    on_event: &mut F,

) -> Result<serde_json::Value, AcpFailure>

where

    F: FnMut(AcpEvent) + Send,

{

    *seq += 1;

    let id = *seq;

    let line = serde_json::json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params});

    write_line(stdin, &line).await?;

    let deadline = tokio::time::Instant::now() + limit;

    loop {

        let next = tokio::select! {

            read = lines.next_line() => read,

            _ = tokio::time::sleep_until(deadline) => {

                return Err(AcpFailure::Refused(format!(

                    "the agent did not answer `{method}` within {}s", limit.as_secs()

                )));

            }

        };

        let raw = match next {

            Ok(Some(raw)) => raw,

            Ok(None) => {

                return Err(AcpFailure::Refused(

                    "the agent exited before it answered".to_string(),

                ))

            }

            Err(error) => {

                return Err(AcpFailure::Refused(format!(

                    "the agent's output could not be read: {error}"

                )))

            }

        };

        let trimmed = raw.trim();

        if trimmed.is_empty() {

            continue;

        }

        let Ok(message) = serde_json::from_str::<serde_json::Value>(trimmed) else {

            continue;

        };

        let is_reply = message.get("id").and_then(|v| v.as_u64()).is_some()

            && message.get("method").is_none();

        if is_reply {

            if message.get("id").and_then(|v| v.as_u64()) != Some(id) {

                continue;

            }

            if let Some(error) = message.get("error") {

                let text = serde_json::to_string(error).unwrap_or_default();

                return Err(AcpFailure::Refused(format!(

                    "the agent refused `{method}`: {}",

                    &text[..text.len().min(200)]

                )));

            }

            return Ok(message

                .get("result")

                .cloned()

                .unwrap_or(serde_json::json!({})));

        }

        handle_incoming(&message, stdin, answer, on_event).await?;

    }

}

async fn handle_incoming<F>(

    message: &serde_json::Value,

    stdin: &mut ChildStdin,

    answer: &mut String,

    on_event: &mut F,

) -> Result<(), AcpFailure>

where

    F: FnMut(AcpEvent) + Send,

{

    let method = message.get("method").and_then(|v| v.as_str()).unwrap_or("");

    if method == "session/request_permission" {

        let Some(id) = message.get("id").and_then(|v| v.as_u64()) else {

            return Ok(());

        };

        let params = message

            .get("params")

            .cloned()

            .unwrap_or(serde_json::json!({}));

        let outcome = match first_allow_option(&params) {

            Some(option) => serde_json::json!({"outcome": "selected", "optionId": option}),

            None => serde_json::json!({"outcome": "cancelled"}),

        };

        write_line(

            stdin,

            &serde_json::json!({"jsonrpc": "2.0", "id": id, "result": {"outcome": outcome}}),

        )

        .await?;

        return Ok(());

    }

    if method != "session/update" {

        return Ok(());

    }

    let update = message

        .get("params")

        .and_then(|p| p.get("update"))

        .cloned()

        .unwrap_or(serde_json::json!({}));

    match update.get("sessionUpdate").and_then(|v| v.as_str()) {

        Some("tool_call") => {

            on_event(AcpEvent::Tool {

                kind: update

                    .get("kind")

                    .and_then(|v| v.as_str())

                    .unwrap_or("tool")

                    .to_string(),

                title: update

                    .get("title")

                    .and_then(|v| v.as_str())

                    .unwrap_or("")

                    .to_string(),

            });

        }

        Some("usage_update") => {

            let meta = update.get("_meta").cloned().unwrap_or(serde_json::json!({}));

            let input = meta.get("cognition.ai/inputTokens").and_then(|v| v.as_u64());

            let output = meta.get("cognition.ai/outputTokens").and_then(|v| v.as_u64());

            if let (Some(input), Some(output)) = (input, output) {

                on_event(AcpEvent::Tokens { input, output });

            }

        }

        Some("agent_message_chunk") => {

            if let Some(piece) = update

                .get("content")

                .and_then(|c| c.get("text"))

                .and_then(|v| v.as_str())

            {

                answer.push_str(piece);

                on_event(AcpEvent::Text {

                    chunk: piece.to_string(),

                });

            }

        }

        _ => {}

    }

    Ok(())

}

async fn write_line(stdin: &mut ChildStdin, value: &serde_json::Value) -> Result<(), AcpFailure> {

    let mut line = serde_json::to_string(value).unwrap_or_default();

    line.push('\n');

    stdin

        .write_all(line.as_bytes())

        .await

        .map_err(|error| AcpFailure::Refused(format!("the agent stopped reading: {error}")))?;

    stdin

        .flush()

        .await

        .map_err(|error| AcpFailure::Refused(format!("the agent stopped reading: {error}")))

}

fn first_allow_option(params: &serde_json::Value) -> Option<String> {

    let options = params.get("options")?.as_array()?;

    let named: Vec<&serde_json::Value> = options

        .iter()

        .filter(|option| option.get("optionId").and_then(|v| v.as_str()).is_some())

        .collect();

    let allow = named.iter().find(|option| {

        option

            .get("kind")

            .and_then(|v| v.as_str())

            .is_some_and(|kind| kind.starts_with("allow"))

    });

    allow

        .or(named.first())

        .and_then(|option| option.get("optionId"))

        .and_then(|v| v.as_str())

        .map(String::from)

}

//! `modifiers` so control chords do not fall through to plain character input.

use crate::acp;

use crate::acp_harness::{AcpEvent, AcpHarness};

use crate::runtime::{CoderRuntimeSession, Control};

use crate::tui::{CoderUi, Entry, Role};

use std::sync::mpsc;

use std::path::PathBuf;

use crossterm::{

    event::{

        self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers,

use std::io::{stderr, stdout};

use std::time::Duration;

#[derive(Debug, Clone)]

pub enum DelegateControl {

    Tool { agent: String, title: String },

    Text(String),

    Done,

    Error(String),

}

pub async fn run_tui() -> Result<(), Box<dyn std::error::Error>> {

    if !atty_is_terminal() {

        println!("Non-interactive terminal detected. Run coder-lite from a TTY.");

    terminal.show_cursor()?;

    let (tx, rx) = mpsc::channel::<Control>();

    let (delegate_tx, delegate_rx) = mpsc::channel::<DelegateControl>();

    let mut ui = CoderUi::new();

    match acp::find_agents().await {

            ui.entries.push(Entry {

                role: Role::Notice,

                text: format!("found ACP agents: {}", list),

                output: None,

            });

            ui.agents = agents;

        }

        Err(_) => {

            ui.entries.push(Entry {

                role: Role::Notice,

                text: "found ACP agents: none".to_string(),

                output: None,

            });

        }

    }

            }

        }

        while let Ok(delegate) = delegate_rx.try_recv() {

            match delegate {

                DelegateControl::Tool { agent, title } => {

                    ui.entries.push(Entry {

                        role: Role::Tool,

                        text: format!("delegate {}: {}", agent, title),

                        output: Some(Vec::new()),

                    });

                    ui.scroll_override = None;

                }

                DelegateControl::Text(chunk) => {

                    if let Some(last) = ui.entries.last_mut() {

                        if last.role == Role::Tool {

                            last.output.get_or_insert_with(Vec::new).push(chunk);

                        }

                    }

                    ui.scroll_override = None;

                }

                DelegateControl::Done => {}

                DelegateControl::Error(message) => {

                    ui.entries.push(Entry {

                        role: Role::Notice,

                        text: format!("delegate error: {}", message),

                        output: None,

                    });

                    ui.scroll_override = None;

                }

            }

        }

        terminal.draw(|f| {

            let size = f.area();

            ui.render(f, size);

                            ui.composer.push('\n');

                        } else if !ui.composer.trim().is_empty() {

                            let prompt = ui.composer.clone();

                            ui.entries.push(Entry {

                                role: Role::You,

                                text: prompt.clone(),

                            });

                            ui.entries.push(Entry {

                                role: Role::Assistant,

                                text: String::new(),

                            });

                            ui.composer.clear();

                            ui.scroll_override = None;

                            ui.loading = true;

                            let mut session = CoderRuntimeSession::new();

                            let tx = tx.clone();

                            tokio::spawn(async move {

                                let _ = session.execute_turn(&prompt, tx).await;

                            });

                            if let Some(rest) = prompt.strip_prefix("/delegate") {

                                let rest = rest.trim_start();

                                if let Some((agent_id, task)) = rest.split_once(' ') {

                                    let agent_id = agent_id.to_string();

                                    let task = task.trim().to_string();

                                    let agent = ui.agents.iter().find(|a| a.id == agent_id).cloned();

                                    ui.entries.push(Entry {

                                        role: Role::You,

                                        text: prompt,

                                        output: None,

                                    });

                                    match agent {

                                        Some(agent) => {

                                            ui.entries.push(Entry {

                                                role: Role::Tool,

                                                text: format!("delegate {}: starting", agent_id),

                                                output: Some(Vec::new()),

                                            });

                                            let cwd =

                                                std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));

                                            let delegate_tx = delegate_tx.clone();

                                            tokio::spawn(async move {

                                                let harness = AcpHarness {

                                                    command: agent.command,

                                                    args: agent.args,

                                                };

                                                let result = harness

                                                    .run(&task, &cwd, |event| match event {

                                                        AcpEvent::Tool { kind: _, title } => {

                                                            let _ = delegate_tx.send(

                                                                DelegateControl::Tool {

                                                                    agent: agent_id.clone(),

                                                                    title,

                                                                },

                                                            );

                                                        }

                                                        AcpEvent::Text { chunk } => {

                                                            let _ = delegate_tx

                                                                .send(DelegateControl::Text(chunk));

                                                        }

                                                        _ => {}

                                                    })

                                                    .await;

                                                if let Err(e) = result {

                                                    let _ = delegate_tx

                                                        .send(DelegateControl::Error(e.to_string()));

                                                } else {

                                                    let _ = delegate_tx.send(DelegateControl::Done);

                                                }

                                            });

                                        }

                                        None => {

                                            ui.entries.push(Entry {

                                                role: Role::Notice,

                                                text: format!("unknown ACP agent: {}", agent_id),

                                                output: None,

                                            });

                                        }

                                    }

                                } else {

                                    ui.entries.push(Entry {

                                        role: Role::Notice,

                                        text: "usage: /delegate <agent> <prompt>".to_string(),

                                        output: None,

                                    });

                                }

                            } else {

                                ui.entries.push(Entry {

                                    role: Role::You,

                                    text: prompt.clone(),

                                    output: None,

                                });

                                ui.entries.push(Entry {

                                    role: Role::Assistant,

                                    text: String::new(),

                                    output: None,

                                });

                                ui.loading = true;

                                let mut session = CoderRuntimeSession::new();

                                let tx = tx.clone();

                                tokio::spawn(async move {

                                    let _ = session.execute_turn(&prompt, tx).await;

                                });

                            }

                        }

                    }

                    KeyEvent {

//! coder-lite: a minimal ratatui TUI boot crate

pub mod acp;

pub mod acp_harness;

pub mod interactive;

pub mod runtime;

pub mod tui;

    }

}

#[derive(Debug, Clone)]

#[derive(Debug, Clone, PartialEq, Eq)]

pub enum Role {

    You,

    Assistant,

pub struct Entry {

    pub role: Role,

    pub text: String,

    pub output: Option<Vec<String>>,

}

#[derive(Debug)]

    pub transcript_height: u16,

    pub loading: bool,

    pub tick: u64,

    pub agents: Vec<crate::acp::Agent>,

}

fn wrap_text(text: &str, width: usize) -> Vec<String> {

            transcript_height: 0,

            loading: false,

            tick: 0,

            agents: Vec::new(),

        }

    }

                lines

            }

            Role::Tool => {

                let text_style = Style::default().fg(TEXT_COLOR).bg(BACKGROUND_COLOR);

                let mut lines = Vec::new();

                // One-line tool call header.

                let header_body = width.saturating_sub(4);

                let header_chunks = wrap_text(&entry.text, header_body);

                let header = header_chunks.first().cloned().unwrap_or_default();

                lines.push(Line::from(vec![

                    Span::styled("  ⏺ ", text_style),

                    Span::styled(header, text_style),

                ]));

                // ~5-line output box, one chunk per line.

                let out = entry.output.as_ref().map_or(&[][..], |v| v.as_slice());

                let start = out.len().saturating_sub(5);

                let window = &out[start..];

                for i in 0..5 {

                    let text = window.get(i).map(String::as_str).unwrap_or("");

                    let clipped = text.chars().take(width.saturating_sub(4)).collect::<String>();

                    lines.push(Line::from(vec![

                        Span::styled("  │ ", text_style),

                        Span::styled(clipped, text_style),

                    ]));

                }

                lines

            }

            _ => {

                let text_style = Style::default().fg(TEXT_COLOR).bg(BACKGROUND_COLOR);

    ui.entries.push(Entry {

        role: Role::Assistant,

        text: "**bold** and *italic*".to_string(),

        output: None,

    });

    let backend = TestBackend::new(80, 24);

use coder_lite::tui::{CoderUi, Entry, Role};

use ratatui::Terminal;

use ratatui::backend::TestBackend;

#[test]

fn renders_delegate_tool_call_and_five_line_box() {

    let mut ui = CoderUi::new();

    ui.entries.push(Entry {

        role: Role::Tool,

        text: "delegate devin: Read src/main.rs".to_string(),

        output: Some(vec![

            "Reading file...".to_string(),

            "Found main()".to_string(),

            "Done".to_string(),

        ]),

    });

    let backend = TestBackend::new(80, 24);

    let mut terminal = Terminal::new(backend).unwrap();

    terminal

        .draw(|f| {

            let area = f.area();

            ui.render(f, area);

        })

        .unwrap();

    let text = terminal

        .backend()

        .buffer()

        .content

        .iter()

        .map(|c| c.symbol())

        .collect::<String>();

    assert!(text.contains("delegate devin: Read src/main.rs"), "{}", text);

    assert!(text.contains("Reading file..."), "{}", text);

    assert!(text.contains("Found main()"), "{}", text);

    assert!(text.contains("Done"), "{}", text);

    assert!(text.contains("│"), "box border not rendered: {}", text);

}