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.
This commit is contained in:
Michael Bolin
GitHub
60
codex-rs/repl/src/cli.rs
Normal file
60
codex-rs/repl/src/cli.rs
Normal file
@@ -0,0 +1,60 @@
|
||||
use clap::ArgAction;
|
||||
use clap::Parser;
|
||||
use codex_core::ApprovalModeCliArg;
|
||||
use codex_core::SandboxModeCliArg;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Command‑line arguments.
|
||||
#[derive(Debug, Parser)]
|
||||
#[command(
|
||||
author,
|
||||
version,
|
||||
about = "Interactive Codex CLI that streams all agent actions."
|
||||
)]
|
||||
pub struct Cli {
|
||||
/// User prompt to start the session.
|
||||
pub prompt: Option<String>,
|
||||
|
||||
/// Override the default model from ~/.codex/config.toml.
|
||||
#[arg(short, long)]
|
||||
pub model: Option<String>,
|
||||
|
||||
/// Optional images to attach to the prompt.
|
||||
#[arg(long, value_name = "FILE")]
|
||||
pub images: Vec<PathBuf>,
|
||||
|
||||
/// Increase verbosity (-v info, -vv debug, -vvv trace).
|
||||
///
|
||||
/// The flag may be passed up to three times. Without any -v the CLI only prints warnings and errors.
|
||||
#[arg(short, long, action = ArgAction::Count)]
|
||||
pub verbose: u8,
|
||||
|
||||
/// Don't use colored ansi output for verbose logging
|
||||
#[arg(long)]
|
||||
pub no_ansi: bool,
|
||||
|
||||
/// Configure when the model requires human approval before executing a command.
|
||||
#[arg(long = "ask-for-approval", short = 'a', value_enum, default_value_t = ApprovalModeCliArg::OnFailure)]
|
||||
pub approval_policy: ApprovalModeCliArg,
|
||||
|
||||
/// Configure the process restrictions when a command is executed.
|
||||
///
|
||||
/// Uses OS-specific sandboxing tools; Seatbelt on OSX, landlock+seccomp on Linux.
|
||||
#[arg(long = "sandbox", short = 's', value_enum, default_value_t = SandboxModeCliArg::NetworkAndFileWriteRestricted)]
|
||||
pub sandbox_policy: SandboxModeCliArg,
|
||||
|
||||
/// Allow running Codex outside a Git repository. By default the CLI
|
||||
/// aborts early when the current working directory is **not** inside a
|
||||
/// Git repo because most agents rely on `git` for interacting with the
|
||||
/// code‑base. Pass this flag if you really know what you are doing.
|
||||
#[arg(long, action = ArgAction::SetTrue, default_value_t = false)]
|
||||
pub allow_no_git_exec: bool,
|
||||
|
||||
/// Record submissions into file as JSON
|
||||
#[arg(short = 'S', long)]
|
||||
pub record_submissions: Option<String>,
|
||||
|
||||
/// Record events into file as JSON
|
||||
#[arg(short = 'E', long)]
|
||||
pub record_events: Option<String>,
|
||||
}
|
||||
423
codex-rs/repl/src/lib.rs
Normal file
423
codex-rs/repl/src/lib.rs
Normal file
@@ -0,0 +1,423 @@
|
||||
use std::io::stdin;
|
||||
use std::io::stdout;
|
||||
use std::io::Write;
|
||||
use std::sync::Arc;
|
||||
|
||||
use codex_core::config::Config;
|
||||
use codex_core::protocol;
|
||||
use codex_core::protocol::FileChange;
|
||||
use codex_core::util::is_inside_git_repo;
|
||||
use codex_core::util::notify_on_sigint;
|
||||
use codex_core::Codex;
|
||||
use owo_colors::OwoColorize;
|
||||
use owo_colors::Style;
|
||||
use tokio::io::AsyncBufReadExt;
|
||||
use tokio::io::BufReader;
|
||||
use tokio::io::Lines;
|
||||
use tokio::io::Stdin;
|
||||
use tokio::sync::Notify;
|
||||
use tracing::debug;
|
||||
use tracing_subscriber::EnvFilter;
|
||||
|
||||
mod cli;
|
||||
pub use cli::Cli;
|
||||
|
||||
/// Initialize the global logger once at startup based on the `--verbose` flag.
|
||||
fn init_logger(verbose: u8, allow_ansi: bool) {
|
||||
// Map -v occurrences to explicit log levels:
|
||||
// 0 → warn (default)
|
||||
// 1 → info
|
||||
// 2 → debug
|
||||
// ≥3 → trace
|
||||
|
||||
let default_level = match verbose {
|
||||
0 => "warn",
|
||||
1 => "info",
|
||||
2 => "codex=debug",
|
||||
_ => "codex=trace",
|
||||
};
|
||||
|
||||
// Only initialize the logger once – repeated calls are ignored. `try_init` will return an
|
||||
// error if another crate (like tests) initialized it first, which we can safely ignore.
|
||||
// By default `tracing_subscriber::fmt()` writes formatted logs to stderr. That is fine when
|
||||
// running the CLI manually but in our smoke tests we capture **stdout** (via `assert_cmd`) and
|
||||
// ignore stderr. As a result none of the `tracing::info!` banners or warnings show up in the
|
||||
// recorded output making it much harder to debug live runs.
|
||||
|
||||
// Switch the logger's writer to stdout so both human runs and the integration tests see the
|
||||
// same stream. Disable ANSI colors because the binary already prints plain text and color
|
||||
// escape codes make predicate matching brittle.
|
||||
let _ = tracing_subscriber::fmt()
|
||||
.with_env_filter(
|
||||
EnvFilter::try_from_default_env()
|
||||
.or_else(|_| EnvFilter::try_new(default_level))
|
||||
.unwrap(),
|
||||
)
|
||||
.with_ansi(allow_ansi)
|
||||
.with_writer(std::io::stdout)
|
||||
.try_init();
|
||||
}
|
||||
|
||||
pub async fn run_main(cli: Cli) -> anyhow::Result<()> {
|
||||
let ctrl_c = notify_on_sigint();
|
||||
|
||||
// Abort early when the user runs Codex outside a Git repository unless
|
||||
// they explicitly acknowledged the risks with `--allow-no-git-exec`.
|
||||
if !cli.allow_no_git_exec && !is_inside_git_repo() {
|
||||
eprintln!(
|
||||
"We recommend running codex inside a git repository. \
|
||||
If you understand the risks, you can proceed with \
|
||||
`--allow-no-git-exec`."
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
|
||||
// Initialize logging before any other work so early errors are captured.
|
||||
init_logger(cli.verbose, !cli.no_ansi);
|
||||
|
||||
let config = Config::load().unwrap_or_default();
|
||||
|
||||
codex_main(cli, config, ctrl_c).await
|
||||
}
|
||||
|
||||
async fn codex_main(mut cli: Cli, cfg: Config, ctrl_c: Arc<Notify>) -> anyhow::Result<()> {
|
||||
let mut builder = Codex::builder();
|
||||
if let Some(path) = cli.record_submissions {
|
||||
builder = builder.record_submissions(path);
|
||||
}
|
||||
if let Some(path) = cli.record_events {
|
||||
builder = builder.record_events(path);
|
||||
}
|
||||
let codex = builder.spawn(Arc::clone(&ctrl_c))?;
|
||||
let init_id = random_id();
|
||||
let init = protocol::Submission {
|
||||
id: init_id.clone(),
|
||||
op: protocol::Op::ConfigureSession {
|
||||
model: cli.model.or(cfg.model),
|
||||
instructions: cfg.instructions,
|
||||
approval_policy: cli.approval_policy.into(),
|
||||
sandbox_policy: cli.sandbox_policy.into(),
|
||||
},
|
||||
};
|
||||
|
||||
out(
|
||||
"initializing session",
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::User,
|
||||
);
|
||||
codex.submit(init).await?;
|
||||
|
||||
// init
|
||||
loop {
|
||||
out(
|
||||
"waiting for session initialization",
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::User,
|
||||
);
|
||||
let event = codex.next_event().await?;
|
||||
if event.id == init_id {
|
||||
if let protocol::EventMsg::Error { message } = event.msg {
|
||||
anyhow::bail!("Error during initialization: {message}");
|
||||
} else {
|
||||
out(
|
||||
"session initialized",
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::User,
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// run loop
|
||||
let mut reader = InputReader::new(ctrl_c.clone());
|
||||
loop {
|
||||
let text = match cli.prompt.take() {
|
||||
Some(input) => input,
|
||||
None => match reader.request_input().await? {
|
||||
Some(input) => input,
|
||||
None => {
|
||||
// ctrl + d
|
||||
println!();
|
||||
return Ok(());
|
||||
}
|
||||
},
|
||||
};
|
||||
if text.trim().is_empty() {
|
||||
continue;
|
||||
}
|
||||
// Interpret certain single‑word commands as immediate termination requests.
|
||||
let trimmed = text.trim();
|
||||
if trimmed == "q" {
|
||||
// Exit gracefully.
|
||||
println!("Exiting…");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let sub = protocol::Submission {
|
||||
id: random_id(),
|
||||
op: protocol::Op::UserInput {
|
||||
items: vec![protocol::InputItem::Text { text }],
|
||||
},
|
||||
};
|
||||
|
||||
out(
|
||||
"sending request to model",
|
||||
MessagePriority::TaskProgress,
|
||||
MessageActor::User,
|
||||
);
|
||||
codex.submit(sub).await?;
|
||||
|
||||
// Wait for agent events **or** user interrupts (Ctrl+C).
|
||||
'inner: loop {
|
||||
// Listen for either the next agent event **or** a SIGINT notification. Using
|
||||
// `tokio::select!` allows the user to cancel a long‑running request that would
|
||||
// otherwise leave the CLI stuck waiting for a server response.
|
||||
let event = {
|
||||
let interrupted = ctrl_c.notified();
|
||||
tokio::select! {
|
||||
_ = interrupted => {
|
||||
// Forward an interrupt to the agent so it can abort any in‑flight task.
|
||||
let _ = codex
|
||||
.submit(protocol::Submission {
|
||||
id: random_id(),
|
||||
op: protocol::Op::Interrupt,
|
||||
})
|
||||
.await;
|
||||
|
||||
// Exit the inner loop and return to the main input prompt. The agent
|
||||
// will emit a `TurnInterrupted` (Error) event which is drained later.
|
||||
break 'inner;
|
||||
}
|
||||
res = codex.next_event() => res?
|
||||
}
|
||||
};
|
||||
|
||||
debug!(?event, "Got event");
|
||||
let id = event.id;
|
||||
match event.msg {
|
||||
protocol::EventMsg::Error { message } => {
|
||||
println!("Error: {message}");
|
||||
break 'inner;
|
||||
}
|
||||
protocol::EventMsg::TaskComplete => break 'inner,
|
||||
protocol::EventMsg::AgentMessage { message } => {
|
||||
out(&message, MessagePriority::UserMessage, MessageActor::Agent)
|
||||
}
|
||||
protocol::EventMsg::SessionConfigured { model } => {
|
||||
debug!(model, "Session initialized");
|
||||
}
|
||||
protocol::EventMsg::ExecApprovalRequest {
|
||||
command,
|
||||
cwd,
|
||||
reason,
|
||||
} => {
|
||||
let reason_str = reason
|
||||
.as_deref()
|
||||
.map(|r| format!(" [{r}]"))
|
||||
.unwrap_or_default();
|
||||
|
||||
let prompt = format!(
|
||||
"approve command in {} {}{} (y/N): ",
|
||||
cwd.display(),
|
||||
command.join(" "),
|
||||
reason_str
|
||||
);
|
||||
let decision = request_user_approval2(prompt)?;
|
||||
let sub = protocol::Submission {
|
||||
id: random_id(),
|
||||
op: protocol::Op::ExecApproval { id, decision },
|
||||
};
|
||||
out(
|
||||
"submitting command approval",
|
||||
MessagePriority::TaskProgress,
|
||||
MessageActor::User,
|
||||
);
|
||||
codex.submit(sub).await?;
|
||||
}
|
||||
protocol::EventMsg::ApplyPatchApprovalRequest {
|
||||
changes,
|
||||
reason: _,
|
||||
grant_root: _,
|
||||
} => {
|
||||
let file_list = changes
|
||||
.keys()
|
||||
.map(|path| path.to_string_lossy().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ");
|
||||
let request =
|
||||
format!("approve apply_patch that will touch? {file_list} (y/N): ");
|
||||
let decision = request_user_approval2(request)?;
|
||||
let sub = protocol::Submission {
|
||||
id: random_id(),
|
||||
op: protocol::Op::PatchApproval { id, decision },
|
||||
};
|
||||
out(
|
||||
"submitting patch approval",
|
||||
MessagePriority::UserMessage,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
codex.submit(sub).await?;
|
||||
}
|
||||
protocol::EventMsg::ExecCommandBegin {
|
||||
command,
|
||||
cwd,
|
||||
call_id: _,
|
||||
} => {
|
||||
out(
|
||||
&format!("running command: '{}' in '{}'", command.join(" "), cwd),
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
}
|
||||
protocol::EventMsg::ExecCommandEnd {
|
||||
stdout,
|
||||
stderr,
|
||||
exit_code,
|
||||
call_id: _,
|
||||
} => {
|
||||
let msg = if exit_code == 0 {
|
||||
"command completed (exit 0)".to_string()
|
||||
} else {
|
||||
// Prefer stderr but fall back to stdout if empty.
|
||||
let err_snippet = if !stderr.trim().is_empty() {
|
||||
stderr.trim()
|
||||
} else {
|
||||
stdout.trim()
|
||||
};
|
||||
format!("command failed (exit {exit_code}): {err_snippet}")
|
||||
};
|
||||
out(&msg, MessagePriority::BackgroundEvent, MessageActor::Agent);
|
||||
out(
|
||||
"sending results to model",
|
||||
MessagePriority::TaskProgress,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
}
|
||||
protocol::EventMsg::PatchApplyBegin { changes, .. } => {
|
||||
// Emit PatchApplyBegin so the front‑end can show progress.
|
||||
let summary = changes
|
||||
.iter()
|
||||
.map(|(path, change)| match change {
|
||||
FileChange::Add { .. } => format!("A {}", path.display()),
|
||||
FileChange::Delete => format!("D {}", path.display()),
|
||||
FileChange::Update { .. } => format!("M {}", path.display()),
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ");
|
||||
|
||||
out(
|
||||
&format!("applying patch: {summary}"),
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
}
|
||||
protocol::EventMsg::PatchApplyEnd { success, .. } => {
|
||||
let status = if success { "success" } else { "failed" };
|
||||
out(
|
||||
&format!("patch application {status}"),
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
out(
|
||||
"sending results to model",
|
||||
MessagePriority::TaskProgress,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
}
|
||||
// Broad fallback; if the CLI is unaware of an event type, it will just
|
||||
// print it as a generic BackgroundEvent.
|
||||
e => {
|
||||
out(
|
||||
&format!("event: {e:?}"),
|
||||
MessagePriority::BackgroundEvent,
|
||||
MessageActor::Agent,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn random_id() -> String {
|
||||
let id: u64 = rand::random();
|
||||
id.to_string()
|
||||
}
|
||||
|
||||
fn request_user_approval2(request: String) -> anyhow::Result<protocol::ReviewDecision> {
|
||||
println!("{}", request);
|
||||
|
||||
let mut line = String::new();
|
||||
stdin().read_line(&mut line)?;
|
||||
let answer = line.trim().to_ascii_lowercase();
|
||||
let is_accepted = answer == "y" || answer == "yes";
|
||||
let decision = if is_accepted {
|
||||
protocol::ReviewDecision::Approved
|
||||
} else {
|
||||
protocol::ReviewDecision::Denied
|
||||
};
|
||||
Ok(decision)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum MessagePriority {
|
||||
BackgroundEvent,
|
||||
TaskProgress,
|
||||
UserMessage,
|
||||
}
|
||||
enum MessageActor {
|
||||
Agent,
|
||||
User,
|
||||
}
|
||||
|
||||
impl From<MessageActor> for String {
|
||||
fn from(actor: MessageActor) -> Self {
|
||||
match actor {
|
||||
MessageActor::Agent => "codex".to_string(),
|
||||
MessageActor::User => "user".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn out(msg: &str, priority: MessagePriority, actor: MessageActor) {
|
||||
let actor: String = actor.into();
|
||||
let style = match priority {
|
||||
MessagePriority::BackgroundEvent => Style::new().fg_rgb::<127, 127, 127>(),
|
||||
MessagePriority::TaskProgress => Style::new().fg_rgb::<200, 200, 200>(),
|
||||
MessagePriority::UserMessage => Style::new().white(),
|
||||
};
|
||||
|
||||
println!("{}> {}", actor.bold(), msg.style(style));
|
||||
}
|
||||
|
||||
struct InputReader {
|
||||
reader: Lines<BufReader<Stdin>>,
|
||||
ctrl_c: Arc<Notify>,
|
||||
}
|
||||
|
||||
impl InputReader {
|
||||
pub fn new(ctrl_c: Arc<Notify>) -> Self {
|
||||
Self {
|
||||
reader: BufReader::new(tokio::io::stdin()).lines(),
|
||||
ctrl_c,
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn request_input(&mut self) -> std::io::Result<Option<String>> {
|
||||
print!("user> ");
|
||||
stdout().flush()?;
|
||||
let interrupted = self.ctrl_c.notified();
|
||||
tokio::select! {
|
||||
line = self.reader.next_line() => {
|
||||
match line? {
|
||||
Some(input) => Ok(Some(input.trim().to_string())),
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
_ = interrupted => {
|
||||
println!();
|
||||
Ok(Some(String::new()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
11
codex-rs/repl/src/main.rs
Normal file
11
codex-rs/repl/src/main.rs
Normal file
@@ -0,0 +1,11 @@
|
||||
use clap::Parser;
|
||||
use codex_repl::run_main;
|
||||
use codex_repl::Cli;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
let cli = Cli::parse();
|
||||
run_main(cli).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user