feat: initial import of Rust implementation of Codex CLI in codex-rs/ (#629)

As stated in `codex-rs/README.md`:

Today, Codex CLI is written in TypeScript and requires Node.js 22+ to
run it. For a number of users, this runtime requirement inhibits
adoption: they would be better served by a standalone executable. As
maintainers, we want Codex to run efficiently in a wide range of
environments with minimal overhead. We also want to take advantage of
operating system-specific APIs to provide better sandboxing, where
possible.

To that end, we are moving forward with a Rust implementation of Codex
CLI contained in this folder, which has the following benefits:

- The CLI compiles to small, standalone, platform-specific binaries.
- Can make direct, native calls to
[seccomp](https://man7.org/linux/man-pages/man2/seccomp.2.html) and
[landlock](https://man7.org/linux/man-pages/man7/landlock.7.html) in
order to support sandboxing on Linux.
- No runtime garbage collection, resulting in lower memory consumption
and better, more predictable performance.

Currently, the Rust implementation is materially behind the TypeScript
implementation in functionality, so continue to use the TypeScript
implmentation for the time being. We will publish native executables via
GitHub Releases as soon as we feel the Rust version is usable.

codex-rs/cli/src/main.rs

@@ -0,0 +1,112 @@
+mod proto;
+mod seatbelt;
+
+use std::path::PathBuf;
+
+use clap::ArgAction;
+use clap::Parser;
+use codex_exec::Cli as ExecCli;
+use codex_interactive::Cli as InteractiveCli;
+use codex_repl::Cli as ReplCli;
+use codex_tui::Cli as TuiCli;
+
+use crate::proto::ProtoCli;
+
+/// Codex CLI
+///
+/// If no subcommand is specified, options will be forwarded to the interactive CLI.
+#[derive(Debug, Parser)]
+#[clap(
+    author,
+    version,
+    // If a sub‑command is given, ignore requirements of the default args.
+    subcommand_negates_reqs = true
+)]
+struct MultitoolCli {
+    #[clap(flatten)]
+    interactive: InteractiveCli,
+
+    #[clap(subcommand)]
+    subcommand: Option<Subcommand>,
+}
+
+#[derive(Debug, clap::Subcommand)]
+enum Subcommand {
+    /// Run Codex non-interactively.
+    #[clap(visible_alias = "e")]
+    Exec(ExecCli),
+
+    /// Run the TUI.
+    #[clap(visible_alias = "t")]
+    Tui(TuiCli),
+
+    /// Run the REPL.
+    #[clap(visible_alias = "r")]
+    Repl(ReplCli),
+
+    /// Run the Protocol stream via stdin/stdout
+    #[clap(visible_alias = "p")]
+    Proto(ProtoCli),
+
+    /// Internal debugging commands.
+    Debug(DebugArgs),
+}
+
+#[derive(Debug, Parser)]
+struct DebugArgs {
+    #[command(subcommand)]
+    cmd: DebugCommand,
+}
+
+#[derive(Debug, clap::Subcommand)]
+enum DebugCommand {
+    /// Run a command under Seatbelt (macOS only).
+    Seatbelt(SeatbeltCommand),
+}
+
+#[derive(Debug, Parser)]
+struct SeatbeltCommand {
+    /// Writable folder for sandbox in full-auto mode (can be specified multiple times).
+    #[arg(long = "writable-root", short = 'w', value_name = "DIR", action = ArgAction::Append, use_value_delimiter = false)]
+    writable_roots: Vec<PathBuf>,
+
+    /// Full command args to run under seatbelt.
+    #[arg(trailing_var_arg = true)]
+    command: Vec<String>,
+}
+
+#[derive(Debug, Parser)]
+struct ReplProto {}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = MultitoolCli::parse();
+
+    match cli.subcommand {
+        None => {
+            codex_interactive::run_main(cli.interactive).await?;
+        }
+        Some(Subcommand::Exec(exec_cli)) => {
+            codex_exec::run_main(exec_cli).await?;
+        }
+        Some(Subcommand::Tui(tui_cli)) => {
+            codex_tui::run_main(tui_cli)?;
+        }
+        Some(Subcommand::Repl(repl_cli)) => {
+            codex_repl::run_main(repl_cli).await?;
+        }
+        Some(Subcommand::Proto(proto_cli)) => {
+            proto::run_main(proto_cli).await?;
+        }
+        Some(Subcommand::Debug(debug_args)) => match debug_args.cmd {
+            DebugCommand::Seatbelt(SeatbeltCommand {
+                command,
+                writable_roots,
+            }) => {
+                seatbelt::run_seatbelt(command, writable_roots).await?;
+            }
+        },
+    }
+
+    Ok(())
+}

codex-rs/cli/src/proto.rs

@@ -0,0 +1,94 @@
+use std::io::IsTerminal;
+
+use clap::Parser;
+use codex_core::protocol::Submission;
+use codex_core::util::notify_on_sigint;
+use codex_core::Codex;
+use tokio::io::AsyncBufReadExt;
+use tokio::io::BufReader;
+use tracing::error;
+use tracing::info;
+
+#[derive(Debug, Parser)]
+pub struct ProtoCli {}
+
+pub async fn run_main(_opts: ProtoCli) -> anyhow::Result<()> {
+    if std::io::stdin().is_terminal() {
+        anyhow::bail!("Protocol mode expects stdin to be a pipe, not a terminal");
+    }
+
+    tracing_subscriber::fmt()
+        .with_writer(std::io::stderr)
+        .init();
+
+    let ctrl_c = notify_on_sigint();
+    let codex = Codex::spawn(ctrl_c.clone())?;
+
+    // Task that reads JSON lines from stdin and forwards to Submission Queue
+    let sq_fut = {
+        let codex = codex.clone();
+        let ctrl_c = ctrl_c.clone();
+        async move {
+            let stdin = BufReader::new(tokio::io::stdin());
+            let mut lines = stdin.lines();
+            loop {
+                let result = tokio::select! {
+                    _ = ctrl_c.notified() => {
+                        info!("Interrupted, exiting");
+                        break
+                    },
+                    res = lines.next_line() => res,
+                };
+
+                match result {
+                    Ok(Some(line)) => {
+                        let line = line.trim();
+                        if line.is_empty() {
+                            continue;
+                        }
+                        match serde_json::from_str::<Submission>(line) {
+                            Ok(sub) => {
+                                if let Err(e) = codex.submit(sub).await {
+                                    error!("{e:#}");
+                                    break;
+                                }
+                            }
+                            Err(e) => {
+                                error!("invalid submission: {e}");
+                            }
+                        }
+                    }
+                    _ => {
+                        info!("Submission queue closed");
+                        break;
+                    }
+                }
+            }
+        }
+    };
+
+    // Task that reads events from the agent and prints them as JSON lines to stdout
+    let eq_fut = async move {
+        loop {
+            let event = tokio::select! {
+                _ = ctrl_c.notified() => break,
+                event = codex.next_event() => event,
+            };
+            match event {
+                Ok(event) => {
+                    let event_str =
+                        serde_json::to_string(&event).expect("JSON serialization failed");
+                    println!("{event_str}");
+                }
+                Err(e) => {
+                    error!("{e:#}");
+                    break;
+                }
+            }
+        }
+        info!("Event queue closed");
+    };
+
+    tokio::join!(sq_fut, eq_fut);
+    Ok(())
+}

codex-rs/cli/src/seatbelt.rs

@@ -0,0 +1,17 @@
+use codex_core::exec::create_seatbelt_command;
+use std::path::PathBuf;
+
+pub(crate) async fn run_seatbelt(
+    command: Vec<String>,
+    writable_roots: Vec<PathBuf>,
+) -> anyhow::Result<()> {
+    let seatbelt_command = create_seatbelt_command(command, &writable_roots);
+    let status = tokio::process::Command::new(seatbelt_command[0].clone())
+        .args(&seatbelt_command[1..])
+        .spawn()
+        .map_err(|e| anyhow::anyhow!("Failed to spawn command: {}", e))?
+        .wait()
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to wait for command: {}", e))?;
+    std::process::exit(status.code().unwrap_or(1));
+}