clone/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-05-24 13:04:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

no dealy or reenroll

Browse Source
This commit is contained in:
Anton Panasenko
2026-03-11 16:42:24 -07:00
parent a4fadaee80
commit 01d0307375
3 changed files with 4 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
codex-rs/app-server/README.md
View File

@@ -80,8 +80,6 @@ Clients must send a single `initialize` request per transport connection before
`initialize.params.capabilities` also supports per-connection notification opt-out via `optOutNotificationMethods`, which is a list of exact method names to suppress for that connection. Matching is exact (no wildcards/prefixes). Unknown method names are accepted and ignored.
For handshake timing tests, set `CODEX_APP_SERVER_INITIALIZE_RESPONSE_DELAY_MS=<milliseconds>` before launching the server. When set to a valid integer, `codex app-server` and `codexd` will wait that long before sending the `initialize` response.
Applications building on top of `codex app-server` should identify themselves via the `clientInfo` parameter.
**Important**: `clientInfo.name` is used to identify the client for the OpenAI Compliance Logs Platform. If

16
codex-rs/app-server/src/message_processor.rs
View File

@@ -77,7 +77,6 @@ use toml::Value as TomlValue;
use tracing::Instrument;
const EXTERNAL_AUTH_REFRESH_TIMEOUT: Duration = Duration::from_secs(10);
const INITIALIZE_RESPONSE_DELAY_MS_ENV_VAR: &str = "CODEX_APP_SERVER_INITIALIZE_RESPONSE_DELAY_MS";
#[derive(Clone)]
struct ExternalAuthRefreshBridge {
@@ -583,21 +582,6 @@ impl MessageProcessor {
platform_family: std::env::consts::FAMILY.to_string(),
platform_os: std::env::consts::OS.to_string(),
};
if let Ok(raw_delay_ms) = std::env::var(INITIALIZE_RESPONSE_DELAY_MS_ENV_VAR) {
match raw_delay_ms.parse::<u64>() {
Ok(delay_ms) => {
tracing::info!(
"delaying initialize response by {delay_ms}ms because {INITIALIZE_RESPONSE_DELAY_MS_ENV_VAR} is set"
);
tokio::time::sleep(Duration::from_millis(delay_ms)).await;
}
Err(err) => {
tracing::warn!(
"ignoring invalid {INITIALIZE_RESPONSE_DELAY_MS_ENV_VAR} value `{raw_delay_ms}`: {err}"
);
}
}
}
self.outgoing
.send_response(connection_request_id, response)
.await;

55
codex-rs/app-server/src/transport.rs
View File

@@ -1447,8 +1447,7 @@ async fn connect_remote_control_websocket(
Err(err) => {
if matches!(
&err,
tungstenite::Error::Http(response)
if matches!(response.status().as_u16(), 404 | 409)
tungstenite::Error::Http(response) if response.status().as_u16() == 404
) {
if let Err(clear_err) = update_persisted_remote_control_enrollment(
remote_control_state_path,
@@ -1464,40 +1463,6 @@ async fn connect_remote_control_websocket(
);
}
*enrollment = None;
let new_enrollment =
enroll_remote_control_server(remote_control_target, &auth).await?;
if let Err(persist_err) = update_persisted_remote_control_enrollment(
remote_control_state_path,
remote_control_target,
auth.account_id.as_deref(),
Some(&new_enrollment),
)
.await
{
warn!(
"failed to persist refreshed remote control enrollment in `{}`: {persist_err}",
remote_control_state_path.display()
);
}
*enrollment = Some(new_enrollment);
let retry_request = build_remote_control_websocket_request(
&remote_control_target.websocket_url,
enrollment
.as_ref()
.expect("refreshed enrollment should exist after re-enroll"),
&auth,
)?;
return connect_async(retry_request)
.await
.map(|(websocket_stream, _response)| websocket_stream)
.map_err(|retry_err| {
std::io::Error::other(format!(
"failed to connect app-server remote control websocket `{}` after refreshing enrollment: {retry_err}",
remote_control_target.websocket_url
))
});
}
Err(std::io::Error::other(format!(
"failed to connect app-server remote control websocket `{}`: {err}",
@@ -1576,7 +1541,6 @@ async fn run_remote_control_websocket_loop(
Ok(websocket_stream) => {
reconnect_backoff = REMOTE_CONTROL_RECONNECT_INITIAL_BACKOFF;
reconnect_attempt = 0;
reconnect_reason = None;
info!(
"connected to app-server remote control websocket: {}",
remote_control_target.websocket_url
@@ -3113,9 +3077,8 @@ mod tests {
let _ = remote_handle.await;
}
async fn assert_remote_control_http_mode_refreshes_stale_persisted_enrollment(
handshake_status: &str,
) {
#[tokio::test]
async fn remote_control_http_mode_clears_stale_persisted_enrollment_after_404() {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("listener should bind");
@@ -3168,7 +3131,7 @@ mod tests {
websocket_request.headers.get("x-codex-server-id"),
Some(&stale_enrollment.server_id)
);
respond_with_status(websocket_request.stream, handshake_status, "").await;
respond_with_status(websocket_request.stream, "404 Not Found", "").await;
let enroll_request = accept_http_request(&listener).await;
assert_eq!(
@@ -3201,16 +3164,6 @@ mod tests {
let _ = remote_handle.await;
}
#[tokio::test]
async fn remote_control_http_mode_refreshes_stale_persisted_enrollment_after_404() {
assert_remote_control_http_mode_refreshes_stale_persisted_enrollment("404 Not Found").await;
}
#[tokio::test]
async fn remote_control_http_mode_refreshes_stale_persisted_enrollment_after_409() {
assert_remote_control_http_mode_refreshes_stale_persisted_enrollment("409 Conflict").await;
}
#[derive(Debug)]
struct CapturedHttpRequest {
stream: TcpStream,