arf-console 0.5.2

//! IPC client for the `arf ipc` subcommand.
//!
//! Uses synchronous std I/O — no tokio runtime needed on the client side.
//!
//! All commands output JSON to stdout (pretty-printed when stdout is a
//! terminal, compact when piped). Errors are written to stderr as JSON
//! with `{"error": {"code": "ERROR_CODE", "message": "...", "hint": "...", "data": ...}}`.

use crate::ipc::protocol::JsonRpcResponse;
use crate::ipc::session::{find_session, list_sessions};
use crate::output::{self, write_json};
use anyhow::{Context, Result};

/// Default transport timeout for client-side socket reads (5 minutes).
const DEFAULT_TRANSPORT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(300);

// ── Exit codes ───────────────────────────────────────────────────────
//
// 0 = success
// 2 = client-side failure before IPC: transport error (socket/timeout)
//     or missing/unreadable code input (NO_CODE_PROVIDED, STDIN_READ_ERROR)
// 3 = session resolution error
// 4 = JSON-RPC protocol error

/// Client-side failure before IPC: transport error (socket connection failed,
/// timeout, etc.) or missing/unreadable code input (stdin is a TTY, read error).
const EXIT_CLIENT: i32 = 2;
/// Session resolution error (no session found, ambiguous PID, etc.).
const EXIT_SESSION: i32 = 3;
/// JSON-RPC protocol error (R_BUSY, INPUT_ALREADY_PENDING, etc.).
const EXIT_PROTOCOL: i32 = 4;

// ── Output helpers ───────────────────────────────────────────────────

fn print_json_or_exit(value: &serde_json::Value) {
    if let Err(error) = output::print_json(value) {
        exit_error(
            EXIT_CLIENT,
            "OUTPUT_ERROR",
            &format!("Failed to write JSON output: {error:#}"),
            None,
            None,
        );
    }
}

/// Print a structured error to stderr as JSON and exit with the given code.
///
/// The error format is (all fields are always present):
/// `{"error": {"code": "ERROR_CODE", "message": "...", "hint": ..., "data": ...}}`
///
/// Error codes are strings for stable matching by consumers:
/// - JSON-RPC codes (negative integers) are mapped to descriptive names
///   (e.g. `"R_BUSY"`, `"PARSE_ERROR"`)
/// - Application codes use uppercase snake_case (e.g. `"TRANSPORT_ERROR"`,
///   `"SESSION_NOT_FOUND"`)
///
/// NOTE: This function calls `std::process::exit()`, so it cannot be
/// tested in-process. Error paths are covered by integration tests in
/// `headless_tests.rs` which run `arf ipc` as a subprocess.
fn exit_error(
    exit_code: i32,
    code: &str,
    message: &str,
    hint: Option<&str>,
    data: Option<&serde_json::Value>,
) -> ! {
    let error = serde_json::json!({
        "error": {
            "code": code,
            "message": message,
            "hint": hint,
            "data": data,
        }
    });
    let pretty = std::io::IsTerminal::is_terminal(&std::io::stderr());
    let write_result = {
        let mut stderr = std::io::stderr().lock();
        write_json(&mut stderr, &error, pretty).and_then(|_| {
            use std::io::Write;
            writeln!(stderr).context("Failed to write JSON newline")
        })
    };
    if let Err(write_error) = write_result {
        eprintln!("Error writing JSON error: {write_error:#}");
    }
    std::process::exit(exit_code);
}

/// Map a JSON-RPC numeric error code to a string identifier and hint.
fn rpc_error_info(code: i32) -> (&'static str, Option<&'static str>) {
    use crate::ipc::protocol::*;
    match code {
        R_BUSY => (
            "R_BUSY",
            Some(
                "R is executing code. Wait for it to finish, or use \
                 'arf ipc session' to check status.",
            ),
        ),
        R_NOT_AT_PROMPT => (
            "R_NOT_AT_PROMPT",
            Some(
                "R is in browser/debug mode or a menu. If triggered by \
                 browser(), use 'arf ipc send \"Q\"' to exit the debugger.",
            ),
        ),
        INPUT_ALREADY_PENDING => (
            "INPUT_ALREADY_PENDING",
            Some(
                "Another IPC input is already queued. Wait for it to \
                 be processed before sending more.",
            ),
        ),
        USER_IS_TYPING => (
            "USER_IS_TYPING",
            Some(
                "The user is typing in the REPL. Check error.data.buffer \
                 for the current input. Wait for them to finish or clear \
                 their input.",
            ),
        ),
        INCOMPLETE_INPUT => (
            "INCOMPLETE_INPUT",
            Some("Complete the R expression before sending it over IPC."),
        ),
        R_EVAL_NOT_ALLOWED => (
            "R_EVAL_NOT_ALLOWED",
            Some(
                "--visible needs no allowlist entry, because it runs the code where the \
                 session shows it rather than silently. The allowlist itself is set only at \
                 startup, through [ipc.eval].allowed_functions or repeated \
                 --ipc-eval-allow-function options, and lifted with --ipc-eval-unrestricted.",
            ),
        ),
        INPUT_NOT_APPROVED => (
            "INPUT_NOT_APPROVED",
            Some("Approve the request in the interactive REPL, then send it again."),
        ),
        PARSE_ERROR => ("PARSE_ERROR", None),
        INVALID_REQUEST => ("INVALID_REQUEST", None),
        METHOD_NOT_FOUND => ("METHOD_NOT_FOUND", None),
        INVALID_PARAMS => ("INVALID_PARAMS", None),
        INTERNAL_ERROR => ("INTERNAL_ERROR", None),
        _ => ("PROTOCOL_ERROR", None),
    }
}

/// Handle a JSON-RPC response: print result or exit with structured error.
///
/// This is the common response handler for all IPC commands that send a
/// JSON-RPC request and print the result. On success, prints the result
/// JSON to stdout. On error, prints a structured error to stderr and exits.
fn handle_response(response: JsonRpcResponse) {
    if let Some(ref error) = response.error {
        let (code, hint) = rpc_error_info(error.code);
        exit_error(
            EXIT_PROTOCOL,
            code,
            &error.message,
            hint,
            error.data.as_ref(),
        );
    }

    match response.result {
        Some(result) => print_json_or_exit(&result),
        None => {
            // JSON-RPC 2.0 requires exactly one of `result` or `error` to be
            // present. Reaching here indicates a server-side bug.
            exit_error(
                EXIT_PROTOCOL,
                "EMPTY_RESPONSE",
                "Server returned a response with neither result nor error (possible server bug)",
                None,
                None,
            );
        }
    }
}

/// List all active arf sessions as JSON.
///
/// Uses `serde_json::to_value` on `SessionInfo` (which derives Serialize)
/// so that new fields are automatically included without manual sync.
pub fn cmd_list() {
    let sessions = list_sessions();

    let sessions_json: Vec<serde_json::Value> = sessions
        .iter()
        .map(|s| {
            serde_json::to_value(s).unwrap_or_else(|e| {
                exit_error(
                    EXIT_PROTOCOL,
                    "SERIALIZATION_ERROR",
                    &format!("Failed to serialize session info: {e}"),
                    Some("This is likely a bug in arf."),
                    None,
                );
            })
        })
        .collect();

    print_json_or_exit(&serde_json::json!({ "sessions": sessions_json }));
}

/// Resolve a session or exit with a structured JSON error.
fn resolve_session(pid: Option<u32>) -> crate::ipc::session::SessionInfo {
    match find_session(pid) {
        Some(session) => session,
        None => {
            if let Some(p) = pid {
                exit_error(
                    EXIT_SESSION,
                    "SESSION_NOT_FOUND",
                    &format!("No active arf session with PID {p}"),
                    Some("Use 'arf ipc list' to see active sessions."),
                    None,
                );
            } else {
                let sessions = list_sessions();
                if sessions.is_empty() {
                    exit_error(
                        EXIT_SESSION,
                        "SESSION_NOT_FOUND",
                        "No active arf sessions found",
                        Some("Start arf with --with-ipc to enable IPC."),
                        None,
                    );
                } else {
                    exit_error(
                        EXIT_SESSION,
                        "SESSION_AMBIGUOUS",
                        "Multiple arf sessions running",
                        Some(
                            "Specify --pid to select one. Use 'arf ipc list' \
                             to see active sessions.",
                        ),
                        None,
                    );
                }
            }
        }
    }
}

/// Exit with a structured JSON error if stdin is a TTY (instant, no I/O).
/// Called before session resolution so TTY errors are reported immediately.
fn require_stdin_not_tty() {
    use std::io::IsTerminal;
    if std::io::stdin().is_terminal() {
        exit_error(
            EXIT_CLIENT,
            "NO_CODE_PROVIDED",
            "No code provided and stdin is a terminal",
            Some("Pass code as an argument or pipe it via stdin."),
            None,
        );
    }
}

/// Read all of stdin into a string, or exit with a structured JSON error on failure.
/// Call `require_stdin_not_tty()` before session resolution to guard against TTY.
fn read_stdin_code() -> String {
    use std::io::Read;
    let mut buf = String::new();
    std::io::stdin()
        .read_to_string(&mut buf)
        .unwrap_or_else(|e| {
            exit_error(
                EXIT_CLIENT,
                "STDIN_READ_ERROR",
                &format!("Failed to read code from stdin: {e}"),
                None,
                None,
            );
        });
    buf
}

/// Evaluate R code in a running arf session.
///
/// On success, prints the structured result as JSON to stdout.
/// R evaluation errors are returned as part of the JSON result (exit 0)
/// — they are a normal response, not an IPC failure.
/// If `code` is `None`, reads from stdin; exits with a JSON error if stdin is a TTY.
/// The TTY check runs first (instant), then session is resolved, then stdin is drained,
/// so a missing-session error is reported without consuming a long stdin stream.
pub fn cmd_eval(code: Option<&str>, pid: Option<u32>, visible: bool, timeout_ms: Option<u64>) {
    if code.is_none() {
        require_stdin_not_tty();
    }
    let session = resolve_session(pid);
    let owned;
    let code = match code {
        Some(c) => c,
        None => {
            owned = read_stdin_code();
            &owned
        }
    };

    let mut params = serde_json::json!({ "code": code, "visible": visible });
    if let Some(ms) = timeout_ms {
        params["timeout_ms"] = serde_json::json!(ms);
    }

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

    // Client transport timeout: match the server-side timeout with a small buffer
    // so the server can respond with a proper timeout error before the client gives up.
    let transport_timeout = match timeout_ms {
        Some(ms) => std::time::Duration::from_millis(ms.saturating_add(5000)),
        None => DEFAULT_TRANSPORT_TIMEOUT + std::time::Duration::from_secs(5),
    };

    let response = send_request(&session.socket_path, &request, transport_timeout);
    handle_response(response);
}

/// Send code as user input to a running arf session.
///
/// If `code` is `None`, reads from stdin; exits with a JSON error if stdin is a TTY.
/// The TTY check runs first (instant), then session is resolved, then stdin is drained,
/// so a missing-session error is reported without consuming a long stdin stream.
pub fn cmd_send(code: Option<&str>, pid: Option<u32>) {
    if code.is_none() {
        require_stdin_not_tty();
    }
    let session = resolve_session(pid);
    let owned;
    let code = match code {
        Some(c) => c,
        None => {
            owned = read_stdin_code();
            &owned
        }
    };

    let request = serde_json::json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "user_input",
        "params": { "code": code }
    });

    let response = send_request(&session.socket_path, &request, DEFAULT_TRANSPORT_TIMEOUT);
    handle_response(response);
}

/// Shut down a running arf headless session.
pub fn cmd_shutdown(pid: Option<u32>) {
    let session = resolve_session(pid);

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

    let response = send_request(&session.socket_path, &request, DEFAULT_TRANSPORT_TIMEOUT);
    handle_response(response);
}

/// Get session information as JSON via the `session` IPC method.
///
/// Output is pretty-printed when stdout is a terminal, compact when piped.
pub fn cmd_session(pid: Option<u32>) {
    let session = resolve_session(pid);

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

    // Session info collection is lightweight; use a short transport timeout.
    let transport_timeout = std::time::Duration::from_secs(15);

    let response = send_request(&session.socket_path, &request, transport_timeout);
    handle_response(response);
}

/// Query command history via the `history` IPC method.
///
/// Output is pretty-printed when stdout is a terminal, compact when piped.
pub fn cmd_history(
    pid: Option<u32>,
    limit: i64,
    all_sessions: bool,
    cwd: Option<&str>,
    grep: Option<&str>,
    since: Option<&str>,
) {
    let session = resolve_session(pid);

    let mut params = serde_json::json!({
        "limit": limit,
        "all_sessions": all_sessions,
    });
    if let Some(cwd) = cwd {
        params["cwd"] = serde_json::Value::String(cwd.to_string());
    }
    if let Some(grep) = grep {
        params["grep"] = serde_json::Value::String(grep.to_string());
    }
    if let Some(since) = since {
        params["since"] = serde_json::Value::String(since.to_string());
    }

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

    let transport_timeout = std::time::Duration::from_secs(15);
    let response = send_request(&session.socket_path, &request, transport_timeout);
    handle_response(response);
}

/// Send a JSON-RPC request to the socket and return the response.
///
/// On transport errors (connection refused, timeout, etc.), exits with
/// a structured JSON error on stderr.
fn send_request(
    socket_path: &str,
    request: &serde_json::Value,
    timeout: std::time::Duration,
) -> JsonRpcResponse {
    match send_request_inner(socket_path, request, timeout) {
        Ok(response) => response,
        Err(e) => {
            // Distinguish protocol-level errors (malformed JSON-RPC responses)
            // from transport-level errors (connection refused, timeout, etc.)
            // so that exit codes match the documented categories.
            // Walk the full anyhow error chain to find serde_json::Error even
            // when it's wrapped by context().
            let is_protocol = e
                .chain()
                .any(|cause| cause.downcast_ref::<serde_json::Error>().is_some());
            if is_protocol {
                exit_error(
                    EXIT_PROTOCOL,
                    "PROTOCOL_ERROR",
                    &format!("{e:#}"),
                    Some("Received an invalid or malformed response from the arf session."),
                    None,
                );
            } else {
                exit_error(
                    EXIT_CLIENT,
                    "TRANSPORT_ERROR",
                    &format!("{e:#}"),
                    Some("Check that the arf session is running and IPC is enabled."),
                    None,
                );
            }
        }
    }
}

/// Inner transport implementation that returns Result for ergonomic error handling.
fn send_request_inner(
    socket_path: &str,
    request: &serde_json::Value,
    timeout: std::time::Duration,
) -> Result<JsonRpcResponse> {
    let body = serde_json::to_string(request)?;

    #[cfg(unix)]
    {
        use std::io::{Read, Write};
        use std::os::unix::net::UnixStream;

        let http_request = format!(
            "POST / HTTP/1.1\r\n\
             Host: localhost\r\n\
             Content-Type: application/json\r\n\
             Content-Length: {}\r\n\
             Connection: close\r\n\
             \r\n{}",
            body.len(),
            body
        );

        let mut stream = UnixStream::connect(socket_path)
            .with_context(|| format!("Failed to connect to {socket_path}"))?;
        stream.set_read_timeout(Some(timeout))?;
        stream.write_all(http_request.as_bytes())?;
        stream.shutdown(std::net::Shutdown::Write)?;

        let mut response_buf = Vec::new();
        stream.read_to_end(&mut response_buf)?;

        parse_http_response(&response_buf)
    }

    #[cfg(windows)]
    {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        use tokio::net::windows::named_pipe::ClientOptions;

        let rt = tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .context("Failed to create tokio runtime")?;

        rt.block_on(async {
            let mut pipe = ClientOptions::new()
                .open(socket_path)
                .with_context(|| format!("Failed to connect to {socket_path}"))?;

            // Send raw JSON (no HTTP wrapping) — the server detects complete
            // JSON and stops reading, so no write shutdown is needed.
            pipe.write_all(body.as_bytes()).await?;
            pipe.flush().await?;

            // Read response with timeout
            let mut response_buf = Vec::new();
            match tokio::time::timeout(timeout, pipe.read_to_end(&mut response_buf)).await {
                Ok(result) => result?,
                Err(_) => anyhow::bail!("Request timed out after {}s", timeout.as_secs()),
            };

            parse_http_response(&response_buf)
        })
    }
}

/// Parse an HTTP response and extract the JSON body.
fn parse_http_response(data: &[u8]) -> Result<JsonRpcResponse> {
    let text = String::from_utf8_lossy(data);

    let body = if let Some(pos) = text.find("\r\n\r\n") {
        &text[pos + 4..]
    } else {
        &text
    };

    serde_json::from_str(body).context("Failed to parse JSON-RPC response")
}