Files
codex/codex-rs/exec-server-cli/src/exec_server_telemetry.rs
T
aagrawal-oai 529d965d80 Add ChatGPT token stdin authentication to exec-server (#59569)
## What changed

- Add `--chatgpt-token-stdin` for remote HTTPS registration and optional `--chatgpt-account-id`, which must match the token's account claim when present. Read a bounded, newline-terminated token from a pipe without persisting it to `auth.json`.
- Load managed configuration using the supplied account, enforce account restrictions, and preserve configured policy-server authentication. Skip ChatGPT policy lookup only for known plans that do not require managed configuration.
- Allow `--exit-on-stdin-close` to cancel pending policy loading, and redact the registration bearer from registry diagnostics.
- Reject incompatible stdin credential options, including flags placed on opposite sides of `forward`, and disallow ChatGPT token stdin authentication with `forward`.

## Testing

Add coverage for account-claim validation, policy selection, policy-server sign-in requirements, shutdown during policy loading, credential flag conflicts, and bearer redaction.

GitOrigin-RevId: b6b50565e1f150b96edf3cee796909a991f1b47f
2026-11-05 04:25:19 +00:00

194 lines
5.7 KiB
Rust

//! Executor telemetry and shutdown coordination shared by both entry points.
use std::future::Future;
use tracing_subscriber::EnvFilter;
use tracing_subscriber::prelude::*;
const DEFAULT_ANALYTICS_ENABLED: bool = false;
const DEFAULT_LOG_FILTER: &str = "error,opentelemetry_sdk=off,opentelemetry_otlp=off";
const OTEL_SERVICE_NAME: &str = "codex-exec-server";
pub(crate) enum ParentLifetime {
Independent,
StdinPipe,
MonitoredStdin(tokio::sync::oneshot::Receiver<()>),
}
pub(crate) enum ShutdownBehavior {
Immediate,
Graceful(tokio::sync::oneshot::Sender<()>),
}
pub(crate) fn init(
config: Option<&codex_core::config::Config>,
) -> (impl Send + Sync, codex_exec_server::ExecServerTelemetry) {
let fmt_layer = tracing_subscriber::fmt::layer()
.with_writer(std::io::stderr)
.with_filter(stderr_env_filter());
let otel = match config {
Some(config) => codex_core::otel_init::build_provider(
config,
env!("CARGO_PKG_VERSION"),
Some(OTEL_SERVICE_NAME),
DEFAULT_ANALYTICS_ENABLED,
)
.unwrap_or_else(|error| {
eprintln!("Could not create otel exporter: {error}");
None
}),
None => None,
};
let provider = otel.as_ref();
codex_core::otel_init::record_process_start(provider, OTEL_SERVICE_NAME);
let otel_logger_layer = provider.and_then(|otel| otel.logger_layer());
let otel_tracing_layer = provider.and_then(|otel| otel.tracing_layer());
let telemetry = provider
.and_then(|otel| otel.metrics())
.cloned()
.map(codex_exec_server::ExecServerTelemetry::new)
.unwrap_or_default();
let _ = tracing_subscriber::registry()
.with(fmt_layer)
.with(otel_tracing_layer)
.with(otel_logger_layer)
.try_init();
tracing::callsite::rebuild_interest_cache();
(otel, telemetry)
}
pub(super) fn monitor_stdin_close() -> tokio::sync::oneshot::Receiver<()> {
let (sender, receiver) = tokio::sync::oneshot::channel();
std::thread::spawn(move || {
if let Err(error) = std::io::copy(&mut std::io::stdin().lock(), &mut std::io::sink()) {
tracing::warn!(%error, "Could not read exec-server parent lifetime pipe");
}
let _ = sender.send(());
});
receiver
}
pub(crate) async fn run_until_shutdown<F, E>(
run: F,
parent_lifetime: ParentLifetime,
shutdown_behavior: ShutdownBehavior,
) -> Result<(), E>
where
F: Future<Output = Result<(), E>>,
{
let parent_disconnected = match parent_lifetime {
ParentLifetime::Independent => None,
ParentLifetime::MonitoredStdin(receiver) => Some(receiver),
ParentLifetime::StdinPipe => Some(monitor_stdin_close()),
};
let parent_disconnected = async {
match parent_disconnected {
Some(receiver) => {
let _ = receiver.await;
}
None => std::future::pending().await,
}
};
let shutdown_signal = match shutdown_signal() {
Ok(signal) => Some(signal),
Err(error) => {
eprintln!("Could not listen for exec-server shutdown signal: {error}");
None
}
};
let shutdown_signal = async {
match shutdown_signal {
Some(signal) => wait_for_shutdown_signal(signal).await,
None => std::future::pending().await,
}
};
run_until_shutdown_with_signals(run, parent_disconnected, shutdown_signal, shutdown_behavior)
.await
}
async fn run_until_shutdown_with_signals<F, E, P, S>(
run: F,
parent_disconnected: P,
shutdown_signal: S,
shutdown_behavior: ShutdownBehavior,
) -> Result<(), E>
where
F: Future<Output = Result<(), E>>,
P: Future<Output = ()>,
S: Future<Output = std::io::Result<()>>,
{
tokio::pin!(run, parent_disconnected, shutdown_signal);
let mut signal_enabled = true;
loop {
tokio::select! {
result = &mut run => return result,
_ = &mut parent_disconnected => {
tracing::info!("Stopping exec-server after its parent closed stdin");
break;
}
signal = &mut shutdown_signal, if signal_enabled => {
match signal {
Ok(()) => break,
Err(error) => {
eprintln!("Could not listen for exec-server shutdown signal: {error}");
signal_enabled = false;
}
}
}
}
}
match shutdown_behavior {
ShutdownBehavior::Immediate => Ok(()),
ShutdownBehavior::Graceful(sender) => {
let _ = sender.send(());
run.await
}
}
}
#[cfg(unix)]
struct ShutdownSignal {
terminate: tokio::signal::unix::Signal,
}
#[cfg(unix)]
fn shutdown_signal() -> std::io::Result<ShutdownSignal> {
Ok(ShutdownSignal {
terminate: tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?,
})
}
#[cfg(unix)]
async fn wait_for_shutdown_signal(mut shutdown_signal: ShutdownSignal) -> std::io::Result<()> {
tokio::select! {
result = tokio::signal::ctrl_c() => result,
_ = shutdown_signal.terminate.recv() => Ok(()),
}
}
#[cfg(not(unix))]
struct ShutdownSignal;
#[cfg(not(unix))]
fn shutdown_signal() -> std::io::Result<ShutdownSignal> {
Ok(ShutdownSignal)
}
#[cfg(not(unix))]
async fn wait_for_shutdown_signal(_: ShutdownSignal) -> std::io::Result<()> {
tokio::signal::ctrl_c().await
}
fn stderr_env_filter() -> EnvFilter {
EnvFilter::try_from_default_env()
.or_else(|_| EnvFilter::try_new(DEFAULT_LOG_FILTER))
.unwrap_or_else(|_| EnvFilter::new("error"))
}
#[cfg(test)]
#[path = "exec_server_telemetry_tests.rs"]
mod tests;