7 Commits

• app-server: retain thread listener across disconnects (#12373)

  - keep the per-thread app-server listener alive when the last client
  unsubscribes or disconnects
  - preserve listener-side active turn history so running `thread/resume`
  can merge an in-progress turn snapshot after reconnect
  - add `ThreadStateManager` regressions for disconnect/unsubscribe
  retention and explicit thread teardown cleanup
  
  Added unit tests, and I manually tested to confirm the fix
  
  ---------
  
  Co-authored-by: Codex <noreply@openai.com>

  Max Johnson · 2026-02-22 05:33:33 +00:00
  37610240ec
• app-server: harden disconnect cleanup paths (#12218)

  Hardens codex-rs/app-server connection lifecycle and outbound routing
  for websocket clients. Fixes some FUD I was having
  
  - Added per-connection disconnect signaling (CancellationToken) for
  websocket transports.
  - Split websocket handling into independent inbound/outbound tasks
  coordinated by cancellation.
  - Changed outbound routing so websocket connections use non-blocking
  try_send; slow/full websocket writers are disconnected instead of
  stalling broadcast delivery.
  - Kept stdio behavior blocking-on-send (no forced disconnect) so local
  stdio clients are not dropped when queues are temporarily full.
  - Simplified outbound router flow by removing deferred
  pending_closed_connections handling.
  - Added guards to drop incoming response/notification/error messages
  from unknown connections.
  - Fixed listener teardown race in thread listener tasks using a
  listener_generation check so stale tasks do not clear newer listeners.
  
  Fixes
  https://linear.app/openai/issue/CODEX-4966/multiclient-handle-slow-notification-consumers
  
    ## Tests
  
    Added/updated transport tests covering:
  
    - broadcast does not block on a slow/full websocket connection
    - stdio connection waits instead of disconnecting on full queue
  
  I (maxj) have tested manually and will retest before landing

  Max Johnson · 2026-02-20 20:35:16 +00:00
  6b1091fc92
• app-server: improve thread resume rejoin flow (#11776)

  thread/resume response includes latest turn with all items, in band so
  no events are stale or lost
  
  Testing
  - e2e tested using app-server-test-client using flow described in
  "Testing Thread Rejoin Behavior" in
  codex-rs/app-server-test-client/README.md
  - e2e tested in codex desktop by reconnecting to a running turn

  Max Johnson · 2026-02-20 05:29:05 +00:00
  b06f91c4fe
• app-server: expose loaded thread status via read/list and notifications (#11786)

  Motivation
  - Today, a newly connected client has no direct way to determine the
  current runtime status of threads from read/list responses alone.
  - This forces clients to infer state from transient events, which can
  lead to stale or inconsistent UI when reconnecting or attaching late.
  
  Changes
  - Add `status` to `thread/read` responses.
  - Add `statuses` to `thread/list` responses.
  - Emit `thread/status/changed` notifications with `threadId` and the new
  status.
  - Track runtime status for all loaded threads and default unknown
  threads to `idle`.
  - Update protocol/docs/tests/schema fixtures for the revised API.
  
  Testing
  - Validated protocol API changes with automated protocol tests and
  regenerated schema/type fixtures.
  - Validated app-server behavior with unit and integration test suites,
  including status transitions and notifications.

  Ruslan Nigmatullin · 2026-02-18 15:20:03 -08:00
  1f54496c48
• feat(core): plumb distinct approval ids for command approvals (#12051)

  zsh fork PR stack:
  - https://github.com/openai/codex/pull/12051 👈 
  - https://github.com/openai/codex/pull/12052
  
  With upcoming support for a fork of zsh that allows us to intercept
  `execve` and run execpolicy checks for each subcommand as part of a
  `CommandExecution`, it will be possible for there to be multiple
  approval requests for a shell command like `/path/to/zsh -lc 'git status
  && rg \"TODO\" src && make test'`.
  
  To support that, this PR introduces a new `approval_id` field across
  core, protocol, and app-server so that we can associate approvals
  properly for subcommands.

  Owen Lin · 2026-02-18 01:55:57 +00:00
  db4d2599b5
• app-server: thread resume subscriptions (#11474)

  This stack layer makes app-server thread event delivery connection-aware
  so resumed/attached threads only emit notifications and approval prompts
  to subscribed connections.
  
  - Added per-thread subscription tracking in `ThreadState`
  (`subscribed_connections`) and mapped subscription ids to `(thread_id,
  connection_id)`.
  - Updated listener lifecycle so removing a subscription or closing a
  connection only removes that connection from the thread’s subscriber
  set; listener shutdown now happens when the last subscriber is gone.
  - Added `connection_closed(connection_id)` plumbing (`lib.rs` ->
  `message_processor.rs` -> `codex_message_processor.rs`) so disconnect
  cleanup happens immediately.
  - Scoped bespoke event handling outputs through `TargetedOutgoing` to
  send requests/notifications only to subscribed connections.
  - Kept existing threadresume behavior while aligning with the latest
  split-loop transport structure.

  Max Johnson · 2026-02-11 16:21:13 -08:00
  c0ecc2e1e1
• refactor: codex app-server ThreadState (#11419)

  this is a no-op functionality wise. consolidates thread-specific message
  processor / event handling state in ThreadState

  Max Johnson · 2026-02-11 12:20:54 -08:00
  b5339a591d