github-copilot-sdk 1.0.21

//! Test-only binary that hosts a single [`github_copilot_sdk::Client`] and then
//! blocks forever, so an external test can terminate *this* process abruptly
//! (simulating an SDK-embedding app process crashing) without ever running any
//! of this process's own cleanup code (`Client::stop`, `force_stop`, or
//! `Drop`).
//!
//! Configuration is passed entirely through environment variables so the
//! caller doesn't need this crate's non-`pub` types:
//! - `HOST_CRASH_FIXTURE_PROGRAM`: CLI program path.
//! - `HOST_CRASH_FIXTURE_PREFIX_ARGS_JSON`: JSON array of prefix args.
//! - `HOST_CRASH_FIXTURE_CWD`: working directory for the spawned CLI.
//! - `HOST_CRASH_FIXTURE_ENV_JSON`: JSON array of `[key, value]` pairs to set
//!   on the spawned CLI's environment.
//! - `HOST_CRASH_FIXTURE_PID_FILE`: path this process atomically publishes the
//!   CLI child's OS process id to, once the client finishes starting.
//! - `HOST_CRASH_FIXTURE_TRANSPORT`: optional `stdio` (default) or `tcp`.

use std::io::Write;
use std::path::PathBuf;

use github_copilot_sdk::{CliProgram, Client, ClientOptions, Transport};

mod pid_file;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let program = std::env::var("HOST_CRASH_FIXTURE_PROGRAM").expect("HOST_CRASH_FIXTURE_PROGRAM");
    let prefix_args: Vec<String> = serde_json::from_str(
        &std::env::var("HOST_CRASH_FIXTURE_PREFIX_ARGS_JSON")
            .expect("HOST_CRASH_FIXTURE_PREFIX_ARGS_JSON"),
    )
    .expect("parse HOST_CRASH_FIXTURE_PREFIX_ARGS_JSON");
    let cwd = std::env::var("HOST_CRASH_FIXTURE_CWD").expect("HOST_CRASH_FIXTURE_CWD");
    let env_pairs: Vec<(String, String)> = serde_json::from_str(
        &std::env::var("HOST_CRASH_FIXTURE_ENV_JSON").expect("HOST_CRASH_FIXTURE_ENV_JSON"),
    )
    .expect("parse HOST_CRASH_FIXTURE_ENV_JSON");
    let pid_file = PathBuf::from(
        std::env::var("HOST_CRASH_FIXTURE_PID_FILE").expect("HOST_CRASH_FIXTURE_PID_FILE"),
    );

    let transport = match std::env::var("HOST_CRASH_FIXTURE_TRANSPORT").as_deref() {
        Ok("tcp") => Transport::Tcp {
            port: 0,
            connection_token: None,
        },
        Ok("stdio") | Err(std::env::VarError::NotPresent) => Transport::Stdio,
        value => panic!("invalid HOST_CRASH_FIXTURE_TRANSPORT: {value:?}"),
    };
    let options = ClientOptions::new()
        .with_program(CliProgram::Path(PathBuf::from(program)))
        .with_prefix_args(prefix_args)
        .with_cwd(PathBuf::from(cwd))
        .with_env(env_pairs)
        .with_use_logged_in_user(false)
        .with_transport(transport);

    let client = Client::start(options).await.expect("start CLI client");
    let pid = client.pid().expect("client reports spawned CLI pid");
    tokio::task::spawn_blocking(move || {
        pid_file::publish_pid_file(&pid_file, |file| write!(file, "{pid}"))
    })
    .await
    .expect("join PID file writer")
    .expect("write pid file");

    // Deliberately leak the client so nothing in this process — including its
    // `Drop` impls — ever runs cleanup code. The external test process
    // terminates this process abruptly (e.g. `TerminateProcess` on Windows)
    // to simulate an SDK-embedding host crashing, and asserts that the CLI
    // still dies via the OS containment primitive alone.
    std::mem::forget(client);

    loop {
        std::thread::sleep(std::time::Duration::from_secs(3600));
    }
}