Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Harden named session lookup in the TUI (#37157)

Charlie Marshc38a60ded2ff
diff --git a/codex-rs/rollout/src/lib.rs b/codex-rs/rollout/src/lib.rs
index 71dac72632..89a81e4c19 100644
--- a/codex-rs/rollout/src/lib.rs
+++ b/codex-rs/rollout/src/lib.rs
@@ -87,6 +87,7 @@ pub use search::search_rollout_matches;
pub use search::search_rollout_paths;
pub use session_index::append_thread_name;
pub use session_index::find_thread_meta_by_name_str;
+pub use session_index::find_thread_meta_candidates_by_name_str;
pub use session_index::find_thread_name_by_id;
pub use session_index::find_thread_names_by_ids;
pub use session_index::remove_thread_name_entries;
diff --git a/codex-rs/rollout/src/session_index.rs b/codex-rs/rollout/src/session_index.rs
index 834dd8a70d..ecfcf44796 100644
--- a/codex-rs/rollout/src/session_index.rs
+++ b/codex-rs/rollout/src/session_index.rs
@@ -7,11 +7,13 @@ use std::path::Path;
use std::path::PathBuf;
use std::sync::LazyLock;
use std::sync::Mutex;
+use std::time::SystemTime;
use crate::reverse_jsonl_scanner::ReverseJsonlScanner;
use crate::reverse_jsonl_scanner::ScanOutcome;
use codex_protocol::ThreadId;
use codex_protocol::protocol::SessionMetaLine;
+use codex_protocol::protocol::SessionSource;
use serde::Deserialize;
use serde::Serialize;
use tokio::io::AsyncBufReadExt;
@@ -150,19 +152,42 @@ pub async fn find_thread_names_by_ids(
Ok(names)
}
-/// Locate a recorded thread rollout and read its session metadata by thread name.
-/// Returns the newest indexed name that still has a readable rollout header.
+/// Locate the readable rollout with the newest modification time for a recorded thread name.
pub async fn find_thread_meta_by_name_str(
codex_home: &Path,
name: &str,
state_db_ctx: Option<&codex_state::StateRuntime>,
) -> std::io::Result<Option<(PathBuf, SessionMetaLine)>> {
+ Ok(find_thread_meta_candidates_by_name_str(
+ codex_home,
+ name,
+ state_db_ctx,
+ /*allowed_sources*/ &[],
+ /*allowed_model_providers*/ &[],
+ )
+ .await?
+ .into_iter()
+ .next())
+}
+
+/// Locate readable rollouts for a recorded thread name, newest modification time first.
+///
+/// Empty filter slices disable their respective filters. Provider filtering only rejects explicit
+/// mismatches because older rollouts omitted provider metadata. Filtering happens before ranking,
+/// so an ineligible newer duplicate cannot hide an older usable session.
+pub async fn find_thread_meta_candidates_by_name_str(
+ codex_home: &Path,
+ name: &str,
+ state_db_ctx: Option<&codex_state::StateRuntime>,
+ allowed_sources: &[SessionSource],
+ allowed_model_providers: &[String],
+) -> std::io::Result<Vec<(PathBuf, SessionMetaLine)>> {
if name.trim().is_empty() {
- return Ok(None);
+ return Ok(Vec::new());
}
let path = session_index_path(codex_home);
if !path.exists() {
- return Ok(None);
+ return Ok(Vec::new());
}
let (tx, mut rx) = tokio::sync::mpsc::channel(1);
let name = name.to_string();
@@ -171,6 +196,7 @@ pub async fn find_thread_meta_by_name_str(
let scan =
tokio::task::spawn_blocking(move || stream_thread_ids_from_end_by_name(&path, &name, tx));
+ let mut candidates = Vec::new();
while let Some(thread_id) = rx.recv().await {
// Keep walking until a matching id resolves to a loadable rollout so an unsaved or partial
// rename cannot shadow an older persisted session with the same name.
@@ -181,15 +207,29 @@ pub async fn find_thread_meta_by_name_str(
)
.await?
&& let Ok(session_meta) = super::list::read_session_meta_line(&path).await
+ && (allowed_sources.is_empty() || allowed_sources.contains(&session_meta.meta.source))
+ && session_meta
+ .meta
+ .model_provider
+ .as_ref()
+ .is_none_or(|provider| {
+ allowed_model_providers.is_empty() || allowed_model_providers.contains(provider)
+ })
{
- drop(rx);
- scan.await.map_err(std::io::Error::other)??;
- return Ok(Some((path, session_meta)));
+ let modified = tokio::fs::metadata(&path)
+ .await
+ .and_then(|metadata| metadata.modified())
+ .unwrap_or(SystemTime::UNIX_EPOCH);
+ candidates.push((modified, path, session_meta));
}
}
scan.await.map_err(std::io::Error::other)??;
+ candidates.sort_by(|(left, _, _), (right, _, _)| right.cmp(left));
- Ok(None)
+ Ok(candidates
+ .into_iter()
+ .map(|(_, path, session_meta)| (path, session_meta))
+ .collect())
}
fn session_index_path(codex_home: &Path) -> PathBuf {
diff --git a/codex-rs/rollout/src/session_index_tests.rs b/codex-rs/rollout/src/session_index_tests.rs
index dee363f73c..0cc20e33b2 100644
--- a/codex-rs/rollout/src/session_index_tests.rs
+++ b/codex-rs/rollout/src/session_index_tests.rs
@@ -20,6 +20,15 @@ fn write_index(path: &Path, lines: &[SessionIndexEntry]) -> std::io::Result<()>
}
fn write_rollout_with_metadata(path: &Path, thread_id: ThreadId) -> std::io::Result<()> {
+ write_rollout_with_source_and_provider(path, thread_id, SessionSource::Cli, "test-provider")
+}
+
+fn write_rollout_with_source_and_provider(
+ path: &Path,
+ thread_id: ThreadId,
+ source: SessionSource,
+ model_provider: &str,
+) -> std::io::Result<()> {
let timestamp = "2024-01-01T00-00-00Z".to_string();
let line = RolloutLine {
timestamp: timestamp.clone(),
@@ -34,12 +43,12 @@ fn write_rollout_with_metadata(path: &Path, thread_id: ThreadId) -> std::io::Res
cwd: ".".into(),
originator: "test_originator".into(),
cli_version: "test_version".into(),
- source: SessionSource::Cli,
+ source,
thread_source: None,
agent_path: None,
agent_nickname: None,
agent_role: None,
- model_provider: Some("test-provider".into()),
+ model_provider: Some(model_provider.to_string()),
base_instructions: None,
dynamic_tools: None,
selected_capability_roots: Vec::new(),
@@ -190,6 +199,78 @@ async fn find_thread_meta_by_name_str_ignores_historical_name_after_rename() ->
Ok(())
}
+#[tokio::test]
+async fn find_thread_meta_candidates_filter_metadata_before_ranking() -> std::io::Result<()> {
+ let temp = TempDir::new()?;
+ let index_path = session_index_path(temp.path());
+ let allowed_id = ThreadId::new();
+ let other_id = ThreadId::new();
+ let noninteractive_id = ThreadId::new();
+ let rollout_dir = temp.path().join("sessions/2024/01/01");
+ let allowed_path = rollout_dir.join(format!("rollout-2024-01-01T00-00-00-{allowed_id}.jsonl"));
+ let other_path = rollout_dir.join(format!("rollout-2024-01-01T00-00-01-{other_id}.jsonl"));
+ let noninteractive_path = rollout_dir.join(format!(
+ "rollout-2024-01-01T00-00-02-{noninteractive_id}.jsonl"
+ ));
+ std::fs::create_dir_all(&rollout_dir)?;
+ write_rollout_with_metadata(&allowed_path, allowed_id)?;
+ write_rollout_with_source_and_provider(
+ &other_path,
+ other_id,
+ SessionSource::Cli,
+ "other-provider",
+ )?;
+ write_rollout_with_source_and_provider(
+ &noninteractive_path,
+ noninteractive_id,
+ SessionSource::Exec,
+ "test-provider",
+ )?;
+ write_index(
+ &index_path,
+ &[
+ SessionIndexEntry {
+ id: allowed_id,
+ thread_name: "same".to_string(),
+ updated_at: "2024-01-01T00:00:00Z".to_string(),
+ },
+ SessionIndexEntry {
+ id: other_id,
+ thread_name: "same".to_string(),
+ updated_at: "2024-01-02T00:00:00Z".to_string(),
+ },
+ SessionIndexEntry {
+ id: noninteractive_id,
+ thread_name: "same".to_string(),
+ updated_at: "2024-01-03T00:00:00Z".to_string(),
+ },
+ ],
+ )?;
+ std::fs::OpenOptions::new()
+ .append(true)
+ .open(&allowed_path)?
+ .set_times(std::fs::FileTimes::new().set_modified(std::time::UNIX_EPOCH))?;
+ let allowed_model_providers = vec!["test-provider".to_string()];
+
+ let found = find_thread_meta_candidates_by_name_str(
+ temp.path(),
+ "same",
+ /*state_db_ctx*/ None,
+ &[SessionSource::Cli],
+ &allowed_model_providers,
+ )
+ .await?;
+
+ assert_eq!(
+ found
+ .into_iter()
+ .map(|(path, session_meta)| (path, session_meta.meta.id))
+ .collect::<Vec<_>>(),
+ vec![(allowed_path, allowed_id)],
+ );
+ Ok(())
+}
+
#[test]
fn find_thread_name_by_id_prefers_latest_entry() -> std::io::Result<()> {
let temp = TempDir::new()?;
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index 95e8564638..2d55735451 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -171,7 +171,13 @@ impl App {
tui.frame_requester().schedule_frame();
}
AppEvent::ResumeSessionByIdOrName(id_or_name) => {
- match crate::lookup_session_target_with_app_server(app_server, &id_or_name).await? {
+ match crate::lookup_session_target_with_app_server(
+ app_server,
+ &self.config,
+ &id_or_name,
+ )
+ .await?
+ {
Some(target_session) => {
return self
.resume_target_session(tui, app_server, target_session)
diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs
index b1062103fa..c79e6add72 100644
--- a/codex-rs/tui/src/lib.rs
+++ b/codex-rs/tui/src/lib.rs
@@ -149,6 +149,7 @@ mod model_catalog;
mod model_migration;
mod motion;
mod multi_agents;
+mod named_session_lookup;
mod notifications;
#[cfg(any(not(debug_assertions), test))]
mod npm_registry;
@@ -622,45 +623,9 @@ pub(crate) fn resume_source_kinds(include_non_interactive: bool) -> Vec<ThreadSo
source_kinds
}
-async fn lookup_session_target_by_name_with_app_server(
- app_server: &mut AppServerSession,
- name: &str,
-) -> color_eyre::Result<Option<resume_picker::SessionTarget>> {
- let mut cursor = None;
- loop {
- let response = app_server
- .thread_list(ThreadListParams {
- cursor: cursor.clone(),
- limit: Some(100),
- sort_key: Some(AppServerThreadSortKey::UpdatedAt),
- sort_direction: None,
- model_providers: None,
- source_kinds: Some(vec![ThreadSourceKind::Cli, ThreadSourceKind::VsCode]),
- archived: Some(false),
- section_id: None,
- parent_thread_id: None,
- ancestor_thread_id: None,
- cwd: None,
- use_state_db_only: false,
- search_term: Some(name.to_string()),
- })
- .await?;
- if let Some(thread) = response
- .data
- .into_iter()
- .find(|thread| thread.name.as_deref() == Some(name))
- {
- return Ok(session_target_from_app_server_thread(thread));
- }
- if response.next_cursor.is_none() {
- return Ok(None);
- }
- cursor = response.next_cursor;
- }
-}
-
async fn lookup_session_target_with_app_server(
app_server: &mut AppServerSession,
+ config: &Config,
id_or_name: &str,
) -> color_eyre::Result<Option<resume_picker::SessionTarget>> {
if Uuid::parse_str(id_or_name).is_ok() {
@@ -691,7 +656,7 @@ async fn lookup_session_target_with_app_server(
};
}
- lookup_session_target_by_name_with_app_server(app_server, id_or_name).await
+ named_session_lookup::lookup(app_server, config, id_or_name).await
}
async fn lookup_latest_session_target_with_app_server(
@@ -1516,7 +1481,8 @@ async fn run_ratatui_app(
let Some(startup_app_server) = app_server.as_mut() else {
unreachable!("app server should be initialized for --fork <id>");
};
- match lookup_session_target_with_app_server(startup_app_server, id_str).await? {
+ match lookup_session_target_with_app_server(startup_app_server, &config, id_str).await?
+ {
Some(target_session) => resume_picker::SessionSelection::Fork(target_session),
None => {
shutdown_app_server_if_present(app_server.take()).await;
@@ -1573,7 +1539,7 @@ async fn run_ratatui_app(
let Some(startup_app_server) = app_server.as_mut() else {
unreachable!("app server should be initialized for --resume <id>");
};
- match lookup_session_target_with_app_server(startup_app_server, id_str).await? {
+ match lookup_session_target_with_app_server(startup_app_server, &config, id_str).await? {
Some(target_session) => resume_picker::SessionSelection::Resume(target_session),
None => {
shutdown_app_server_if_present(app_server.take()).await;
@@ -3217,71 +3183,6 @@ mod tests {
Ok(())
}
- #[tokio::test]
- async fn lookup_session_target_by_name_uses_backend_title_search() -> color_eyre::Result<()> {
- Box::pin(async {
- let temp_dir = TempDir::new()?;
- let config = build_config(&temp_dir).await?;
- let thread_id = ThreadId::new();
- let rollout_path = temp_dir
- .path()
- .join("sessions/2025/02/01")
- .join(format!("rollout-2025-02-01T10-00-00-{thread_id}.jsonl"));
- let rollout_dir = rollout_path.parent().expect("rollout parent");
- std::fs::create_dir_all(rollout_dir)?;
- std::fs::write(&rollout_path, "")?;
-
- let state_runtime = codex_state::StateRuntime::init(
- codex_state::SqliteConfig::new_for_testing(config.codex_home.as_path().abs()),
- config.model_provider_id.clone(),
- )
- .await
- .map_err(std::io::Error::other)?;
- state_runtime
- .mark_backfill_complete(/*last_watermark*/ None)
- .await
- .map_err(std::io::Error::other)?;
-
- let session_cwd = temp_dir.path().join("project");
- std::fs::create_dir_all(&session_cwd)?;
- let created_at = chrono::DateTime::parse_from_rfc3339("2025-02-01T10:00:00Z")
- .expect("timestamp should parse")
- .with_timezone(&chrono::Utc);
- let mut builder = codex_state::ThreadMetadataBuilder::new(
- thread_id,
- rollout_path.clone(),
- created_at,
- serde_json::from_value(serde_json::json!("cli"))
- .expect("cli session source should deserialize"),
- );
- builder.cwd = session_cwd;
- let mut metadata = builder.build(config.model_provider_id.as_str());
- metadata.title = "saved-session".to_string();
- metadata.first_user_message = Some("preview text".to_string());
- state_runtime
- .upsert_thread(&metadata)
- .await
- .map_err(std::io::Error::other)?;
-
- let mut app_server = AppServerSession::new(
- codex_app_server_client::AppServerClient::InProcess(
- start_test_embedded_app_server(config).await?,
- ),
- ThreadParamsMode::Embedded,
- );
- let target =
- lookup_session_target_by_name_with_app_server(&mut app_server, "saved-session")
- .await?;
- let target = target.expect("name lookup should find the saved thread");
- assert_eq!(target.path, Some(rollout_path));
- assert_eq!(target.thread_id, thread_id);
-
- app_server.shutdown().await?;
- Ok(())
- })
- .await
- }
-
#[tokio::test]
async fn embedded_app_server_start_failure_is_returned() -> color_eyre::Result<()> {
let temp_dir = TempDir::new()?;
diff --git a/codex-rs/tui/src/named_session_lookup.rs b/codex-rs/tui/src/named_session_lookup.rs
new file mode 100644
index 0000000000..e1ab21bc8d
--- /dev/null
+++ b/codex-rs/tui/src/named_session_lookup.rs
@@ -0,0 +1,297 @@
+use std::path::Path;
+
+use crate::app_server_session::AppServerSession;
+use crate::legacy_core::config::Config;
+use crate::resume_picker::SessionTarget;
+use codex_app_server_protocol::Thread as AppServerThread;
+use codex_app_server_protocol::ThreadHistoryMode;
+use codex_app_server_protocol::ThreadListParams;
+use codex_app_server_protocol::ThreadSortKey;
+use codex_protocol::ThreadId;
+use codex_protocol::protocol::SessionMeta;
+use codex_protocol::protocol::SessionSource;
+
+// Keep this aligned with `resume_source_kinds(/*include_non_interactive*/ false)`.
+const RESUME_SESSION_SOURCES: [SessionSource; 2] = [SessionSource::Cli, SessionSource::VSCode];
+
+/// Selects whether a local lookup can repair SQLite metadata from rollout files.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum SessionNameLookupMode {
+ StateDbOnly,
+ ScanAndRepair,
+}
+
+/// Selects the rollout collection that a local candidate must belong to.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum SessionCollection {
+ Active,
+ Archived,
+}
+
+/// An exact-name match and the rollout metadata verified for local candidates.
+pub(super) struct NamedSessionCandidate {
+ pub(super) thread: AppServerThread,
+ /// Remote candidates never inspect local rollout files and therefore have no session metadata.
+ pub(super) session_meta: Option<SessionMeta>,
+}
+
+/// Lazily pages through exact-name matches and skips unusable local rollouts.
+pub(super) struct NamedSessionCandidates<'a> {
+ name: &'a str,
+ codex_home: &'a Path,
+ collection: SessionCollection,
+ mode: SessionNameLookupMode,
+ search_term: Option<&'a str>,
+ cursor: Option<String>,
+ pending: std::vec::IntoIter<AppServerThread>,
+ has_more: bool,
+}
+
+/// Resolves an active session by exact name.
+///
+/// Local lookups treat a usable SQLite match as authoritative and consult legacy rollout metadata
+/// only to recover a missing or unusable row. Remote workspaces retain the backend's scan behavior.
+pub(super) async fn lookup(
+ app_server: &mut AppServerSession,
+ config: &Config,
+ name: &str,
+) -> color_eyre::Result<Option<SessionTarget>> {
+ if app_server.uses_remote_workspace() {
+ return Ok(lookup_from_app_server(
+ app_server,
+ config,
+ name,
+ SessionNameLookupMode::ScanAndRepair,
+ )
+ .await?
+ .and_then(super::session_target_from_app_server_thread));
+ }
+
+ if let Some(thread) =
+ lookup_from_app_server(app_server, config, name, SessionNameLookupMode::StateDbOnly).await?
+ {
+ return Ok(super::session_target_from_app_server_thread(thread));
+ }
+
+ if let Some(target) = lookup_legacy_index_target(app_server, config, name).await? {
+ return Ok(Some(target));
+ }
+
+ Ok(lookup_from_app_server(
+ app_server,
+ config,
+ name,
+ SessionNameLookupMode::ScanAndRepair,
+ )
+ .await?
+ .and_then(super::session_target_from_app_server_thread))
+}
+
+/// Recovers a local target from legacy metadata without overriding an explicit SQLite name.
+///
+/// Rewriting the recovered name into SQLite is best effort and cannot invalidate a usable target.
+async fn lookup_legacy_index_target(
+ app_server: &mut AppServerSession,
+ config: &Config,
+ name: &str,
+) -> color_eyre::Result<Option<SessionTarget>> {
+ // Older rollouts omitted the provider and were historically assigned to the current provider
+ // during scans, so only reject an explicit mismatch here.
+ let candidates = codex_rollout::find_thread_meta_candidates_by_name_str(
+ config.codex_home.as_path(),
+ name,
+ /*state_db_ctx*/ None,
+ &RESUME_SESSION_SOURCES,
+ std::slice::from_ref(&config.model_provider_id),
+ )
+ .await?;
+ for (path, session_meta) in candidates {
+ if !path.starts_with(config.codex_home.join(codex_rollout::SESSIONS_SUBDIR)) {
+ continue;
+ }
+
+ // `thread/read` resolves the candidate's current SQLite title. A conflicting title means
+ // the sidecar is stale, while a missing legacy title is the partial-write case it recovers.
+ let thread = app_server
+ .thread_read(session_meta.meta.id, /*include_turns*/ false)
+ .await?;
+ if !current_name_is_compatible(&thread, name) {
+ continue;
+ }
+ if let Err(err) = app_server
+ .thread_set_name(session_meta.meta.id, name.to_string())
+ .await
+ {
+ tracing::warn!(
+ thread_id = %session_meta.meta.id,
+ %err,
+ "failed to repair recovered thread name"
+ );
+ }
+ return Ok(Some(SessionTarget {
+ path: Some(path),
+ thread_id: session_meta.meta.id,
+ }));
+ }
+ Ok(None)
+}
+
+/// Allows a missing SQLite name only for legacy threads, whose name may exist only in the index.
+fn current_name_is_compatible(thread: &AppServerThread, name: &str) -> bool {
+ match thread.history_mode {
+ ThreadHistoryMode::Legacy => thread.name.as_deref().is_none_or(|current| current == name),
+ ThreadHistoryMode::Paginated => thread.name.as_deref() == Some(name),
+ }
+}
+
+/// Returns an eligible active thread for one SQLite-only or scan-and-repair lookup pass.
+///
+/// Local resume candidates also honor source/provider filters and reject stale scanned titles.
+async fn lookup_from_app_server(
+ app_server: &mut AppServerSession,
+ config: &Config,
+ name: &str,
+ mode: SessionNameLookupMode,
+) -> color_eyre::Result<Option<AppServerThread>> {
+ let mut candidates = NamedSessionCandidates::new(
+ name,
+ config.codex_home.as_path(),
+ SessionCollection::Active,
+ mode,
+ Some(name),
+ );
+ while let Some(candidate) = candidates.next(app_server).await? {
+ if let Some(session_meta) = candidate.session_meta
+ && (!RESUME_SESSION_SOURCES.contains(&session_meta.source)
+ || session_meta
+ .model_provider
+ .as_deref()
+ .is_some_and(|provider| provider != config.model_provider_id.as_str()))
+ {
+ continue;
+ }
+ if mode == SessionNameLookupMode::ScanAndRepair && !app_server.uses_remote_workspace() {
+ // Scans can surface stale sidecar names, so verify the candidate's current title.
+ let thread = app_server
+ .thread_read(
+ ThreadId::from_string(&candidate.thread.id)?,
+ /*include_turns*/ false,
+ )
+ .await?;
+ if !current_name_is_compatible(&thread, name) {
+ continue;
+ }
+ return Ok(Some(thread));
+ }
+ return Ok(Some(candidate.thread));
+ }
+ Ok(None)
+}
+
+impl<'a> NamedSessionCandidates<'a> {
+ pub(super) fn new(
+ name: &'a str,
+ codex_home: &'a Path,
+ collection: SessionCollection,
+ mode: SessionNameLookupMode,
+ search_term: Option<&'a str>,
+ ) -> Self {
+ Self {
+ name,
+ codex_home,
+ collection,
+ mode,
+ search_term,
+ cursor: None,
+ pending: Vec::new().into_iter(),
+ has_more: true,
+ }
+ }
+
+ /// Returns the next exact-name match, advancing through server pages as needed.
+ ///
+ /// Local candidates must have a rollout in the requested collection with a matching session
+ /// header; remote candidates preserve server-side lookup without touching local files.
+ pub(super) async fn next(
+ &mut self,
+ app_server: &mut AppServerSession,
+ ) -> color_eyre::Result<Option<NamedSessionCandidate>> {
+ loop {
+ if let Some(thread) = self.pending.next() {
+ if thread.name.as_deref() != Some(self.name) {
+ continue;
+ }
+ let session_meta = if app_server.uses_remote_workspace() {
+ None
+ } else {
+ let (Ok(thread_id), Some(path)) =
+ (ThreadId::from_string(&thread.id), thread.path.as_deref())
+ else {
+ continue;
+ };
+ let Some(path) = codex_rollout::existing_rollout_path(path).await else {
+ continue;
+ };
+ let expected_root = self.codex_home.join(match self.collection {
+ SessionCollection::Active => codex_rollout::SESSIONS_SUBDIR,
+ SessionCollection::Archived => codex_rollout::ARCHIVED_SESSIONS_SUBDIR,
+ });
+ if !path.starts_with(expected_root) {
+ continue;
+ }
+ let Ok(session_meta) =
+ codex_rollout::read_session_meta_line(path.as_path()).await
+ else {
+ continue;
+ };
+ if session_meta.meta.id != thread_id {
+ continue;
+ }
+ Some(session_meta.meta)
+ };
+ return Ok(Some(NamedSessionCandidate {
+ thread,
+ session_meta,
+ }));
+ }
+
+ if !self.has_more {
+ return Ok(None);
+ }
+ // Only embedded SQLite supports recency sorting; scanners and older daemons use mtime.
+ let sort_key = if self.mode == SessionNameLookupMode::StateDbOnly
+ && app_server.uses_embedded_app_server()
+ {
+ ThreadSortKey::RecencyAt
+ } else {
+ ThreadSortKey::UpdatedAt
+ };
+ let response = app_server
+ .thread_list(ThreadListParams {
+ cursor: self.cursor.clone(),
+ limit: Some(100),
+ sort_key: Some(sort_key),
+ sort_direction: None,
+ model_providers: None,
+ source_kinds: Some(super::resume_source_kinds(
+ /*include_non_interactive*/ false,
+ )),
+ archived: Some(self.collection == SessionCollection::Archived),
+ section_id: None,
+ parent_thread_id: None,
+ ancestor_thread_id: None,
+ cwd: None,
+ use_state_db_only: self.mode == SessionNameLookupMode::StateDbOnly,
+ search_term: self.search_term.map(str::to_string),
+ })
+ .await?;
+ self.cursor = response.next_cursor;
+ self.has_more = self.cursor.is_some();
+ self.pending = response.data.into_iter();
+ }
+ }
+}
+
+#[cfg(test)]
+#[path = "named_session_lookup_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/named_session_lookup_tests.rs b/codex-rs/tui/src/named_session_lookup_tests.rs
new file mode 100644
index 0000000000..eb6e01ad93
--- /dev/null
+++ b/codex-rs/tui/src/named_session_lookup_tests.rs
@@ -0,0 +1,513 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use codex_protocol::ThreadId;
+use codex_protocol::protocol::SessionMeta;
+use codex_protocol::protocol::SessionMetaLine;
+use codex_protocol::protocol::SessionSource;
+use codex_protocol::protocol::ThreadHistoryMode;
+use codex_state::ThreadMetadataBuilder;
+use codex_utils_absolute_path::test_support::PathExt;
+use pretty_assertions::assert_eq;
+use tempfile::TempDir;
+
+use super::lookup;
+use crate::app_server_session::AppServerSession;
+use crate::app_server_session::ThreadParamsMode;
+use crate::legacy_core::config::Config;
+use crate::legacy_core::config::ConfigBuilder;
+use crate::tests::start_test_embedded_app_server;
+
+async fn build_config(temp_dir: &TempDir) -> std::io::Result<Config> {
+ ConfigBuilder::default()
+ .codex_home(temp_dir.path().to_path_buf())
+ .build()
+ .await
+}
+
+async fn state_runtime(config: &Config) -> std::io::Result<Arc<codex_state::StateRuntime>> {
+ let runtime = codex_state::StateRuntime::init(
+ codex_state::SqliteConfig::new_for_testing(config.codex_home.as_path().abs()),
+ config.model_provider_id.clone(),
+ )
+ .await
+ .map_err(std::io::Error::other)?;
+ runtime
+ .mark_backfill_complete(/*last_watermark*/ None)
+ .await
+ .map_err(std::io::Error::other)?;
+ Ok(runtime)
+}
+
+async fn lookup_name(
+ config: &Config,
+ name: &str,
+) -> color_eyre::Result<Option<crate::resume_picker::SessionTarget>> {
+ let mut app_server = AppServerSession::new(
+ codex_app_server_client::AppServerClient::InProcess(
+ start_test_embedded_app_server(config.clone()).await?,
+ ),
+ ThreadParamsMode::Embedded,
+ );
+ let target = lookup(&mut app_server, config, name).await?;
+ app_server.shutdown().await?;
+ Ok(target)
+}
+
+async fn upsert_thread(
+ runtime: &codex_state::StateRuntime,
+ metadata: codex_state::ThreadMetadata,
+) -> std::io::Result<()> {
+ runtime
+ .upsert_thread(&metadata)
+ .await
+ .map_err(std::io::Error::other)
+}
+
+fn thread_metadata(
+ config: &Config,
+ thread_id: ThreadId,
+ rollout_path: PathBuf,
+ title: &str,
+) -> codex_state::ThreadMetadata {
+ let created_at = chrono::DateTime::parse_from_rfc3339("2025-02-01T10:00:00Z")
+ .expect("timestamp should parse")
+ .with_timezone(&chrono::Utc);
+ let mut builder = ThreadMetadataBuilder::new(
+ thread_id,
+ rollout_path,
+ created_at,
+ serde_json::from_value(serde_json::json!("cli"))
+ .expect("cli session source should deserialize"),
+ );
+ builder.cwd = config.codex_home.join("project").to_path_buf();
+ let mut metadata = builder.build(config.model_provider_id.as_str());
+ metadata.title = title.to_string();
+ metadata.first_user_message = Some("preview text".to_string());
+ metadata.preview = metadata.first_user_message.clone();
+ metadata
+}
+
+fn write_rollout(
+ config: &Config,
+ thread_id: ThreadId,
+ timestamp: &str,
+ preview: &str,
+ source: SessionSource,
+ history_mode: ThreadHistoryMode,
+) -> color_eyre::Result<PathBuf> {
+ let rollout_path = config
+ .codex_home
+ .join("sessions/2025/02/01")
+ .join(format!("rollout-2025-02-01T10-00-00-{thread_id}.jsonl"));
+ std::fs::create_dir_all(rollout_path.parent().expect("rollout parent"))?;
+ let session_meta = SessionMetaLine {
+ meta: SessionMeta {
+ session_id: thread_id.into(),
+ id: thread_id,
+ timestamp: timestamp.to_string(),
+ cwd: config.codex_home.join("project").to_path_buf(),
+ originator: "codex".to_string(),
+ cli_version: "0.0.0".to_string(),
+ source,
+ model_provider: Some(config.model_provider_id.clone()),
+ history_mode,
+ ..Default::default()
+ },
+ git: None,
+ };
+ let lines = [
+ serde_json::json!({
+ "timestamp": timestamp,
+ "type": "session_meta",
+ "payload": session_meta,
+ }),
+ serde_json::json!({
+ "timestamp": timestamp,
+ "type": "response_item",
+ "payload": {
+ "type": "message",
+ "role": "user",
+ "content": [{"type": "input_text", "text": preview}],
+ },
+ }),
+ ];
+ std::fs::write(
+ &rollout_path,
+ lines
+ .iter()
+ .map(serde_json::Value::to_string)
+ .collect::<Vec<_>>()
+ .join("\n")
+ + "\n",
+ )?;
+ Ok(rollout_path.to_path_buf())
+}
+
+async fn add_scan_sentinel(config: &Config, search_term: &str) -> color_eyre::Result<ThreadId> {
+ let thread_id = ThreadId::new();
+ write_rollout(
+ config,
+ thread_id,
+ "2025-02-01T11:00:00Z",
+ "scan sentinel",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ codex_rollout::append_thread_name(
+ config.codex_home.as_path(),
+ thread_id,
+ &format!("{search_term}-scan-sentinel"),
+ )
+ .await?;
+ Ok(thread_id)
+}
+
+#[tokio::test]
+async fn uses_sqlite_title_without_scanning_rollouts() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let thread_id = ThreadId::new();
+ let rollout_path = write_rollout(
+ &config,
+ thread_id,
+ "2025-02-01T10:00:00Z",
+ "preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ upsert_thread(
+ &runtime,
+ thread_metadata(&config, thread_id, rollout_path.clone(), "saved-session"),
+ )
+ .await?;
+ // Scan-and-repair would discover this matching rollout and insert it into SQLite.
+ let scan_sentinel_id = add_scan_sentinel(&config, "saved-session").await?;
+ let duplicate_id = ThreadId::new();
+ write_rollout(
+ &config,
+ duplicate_id,
+ "2025-02-01T11:00:00Z",
+ "newer duplicate",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), duplicate_id, "saved-session")
+ .await?;
+
+ let target = lookup_name(&config, "saved-session").await?;
+
+ assert_eq!(
+ (
+ target.map(|target| (target.path, target.thread_id)),
+ runtime
+ .get_thread(scan_sentinel_id)
+ .await
+ .map_err(std::io::Error::other)?,
+ runtime
+ .get_thread(duplicate_id)
+ .await
+ .map_err(std::io::Error::other)?,
+ ),
+ (Some((Some(rollout_path), thread_id)), None, None),
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn skips_stale_sqlite_candidate_for_valid_duplicate() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let valid_id = ThreadId::new();
+ let valid_path = write_rollout(
+ &config,
+ valid_id,
+ "2025-02-01T10:00:00Z",
+ "valid preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ upsert_thread(
+ &runtime,
+ thread_metadata(&config, valid_id, valid_path.clone(), "saved-session"),
+ )
+ .await?;
+
+ let stale_id = ThreadId::new();
+ let stale_path = write_rollout(
+ &config,
+ ThreadId::new(),
+ "2025-02-01T11:00:00Z",
+ "stale preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ upsert_thread(
+ &runtime,
+ thread_metadata(&config, stale_id, stale_path, "saved-session"),
+ )
+ .await?;
+
+ let target = lookup_name(&config, "saved-session").await?;
+
+ assert_eq!(
+ target.map(|target| (target.path, target.thread_id)),
+ Some((Some(valid_path), valid_id)),
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn validates_sqlite_candidate_filters_against_rollout() -> color_eyre::Result<()> {
+ let mut targets = Vec::new();
+ for (source, model_provider) in [
+ (SessionSource::Exec, None),
+ (SessionSource::Cli, Some("other-provider")),
+ ] {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let thread_id = ThreadId::new();
+ let mut rollout_config = config.clone();
+ if let Some(model_provider) = model_provider {
+ rollout_config.model_provider_id = model_provider.to_string();
+ }
+ let rollout_path = write_rollout(
+ &rollout_config,
+ thread_id,
+ "2025-02-01T10:00:00Z",
+ "preview",
+ source,
+ ThreadHistoryMode::Legacy,
+ )?;
+ upsert_thread(
+ &runtime,
+ thread_metadata(&config, thread_id, rollout_path, "saved-session"),
+ )
+ .await?;
+
+ targets.push(
+ lookup_name(&config, "saved-session")
+ .await?
+ .map(|target| target.thread_id),
+ );
+ }
+
+ assert_eq!(targets, vec![None, None]);
+ Ok(())
+}
+
+#[tokio::test]
+async fn recovers_legacy_index_name_without_requiring_sidecar_rewrite() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let stale_id = ThreadId::new();
+ upsert_thread(
+ &runtime,
+ thread_metadata(
+ &config,
+ stale_id,
+ config
+ .codex_home
+ .join("missing-rollout.jsonl")
+ .to_path_buf(),
+ "saved-session",
+ ),
+ )
+ .await?;
+
+ let thread_id = ThreadId::new();
+ let rollout_path = write_rollout(
+ &config,
+ thread_id,
+ "2025-02-01T11:00:00Z",
+ "preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), thread_id, "saved-session")
+ .await?;
+ // The direct index lookup should not scan and repair other matching rollouts.
+ let scan_sentinel_id = add_scan_sentinel(&config, "saved-session").await?;
+
+ let index_path = config.codex_home.join("session_index.jsonl");
+ let original_permissions = std::fs::metadata(&index_path)?.permissions();
+ let mut read_only_permissions = original_permissions.clone();
+ read_only_permissions.set_readonly(true);
+ std::fs::set_permissions(&index_path, read_only_permissions)?;
+ let target = lookup_name(&config, "saved-session").await;
+ std::fs::set_permissions(&index_path, original_permissions)?;
+ let target = target?;
+
+ assert_eq!(
+ (
+ target.map(|target| (target.path, target.thread_id)),
+ runtime
+ .get_thread(thread_id)
+ .await
+ .map_err(std::io::Error::other)?
+ .map(|metadata| metadata.title),
+ runtime
+ .get_thread(scan_sentinel_id)
+ .await
+ .map_err(std::io::Error::other)?,
+ ),
+ (
+ Some((Some(rollout_path), thread_id)),
+ Some("saved-session".to_string()),
+ None,
+ ),
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn skips_stale_legacy_index_candidate() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let stale_id = ThreadId::new();
+ let stale_path = write_rollout(
+ &config,
+ stale_id,
+ "2025-02-01T10:00:00Z",
+ "preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ upsert_thread(
+ &runtime,
+ thread_metadata(&config, stale_id, stale_path.clone(), "current-session"),
+ )
+ .await?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), stale_id, "saved-session")
+ .await?;
+
+ let fallback_id = ThreadId::new();
+ let fallback_path = write_rollout(
+ &config,
+ fallback_id,
+ "2025-02-01T11:00:00Z",
+ "fallback",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), fallback_id, "saved-session")
+ .await?;
+ for (path, timestamp) in [
+ (&stale_path, "2025-02-04T10:00:00Z"),
+ (&fallback_path, "2025-02-03T10:00:00Z"),
+ ] {
+ let modified = chrono::DateTime::parse_from_rfc3339(timestamp)?.into();
+ std::fs::OpenOptions::new()
+ .append(true)
+ .open(path)?
+ .set_times(std::fs::FileTimes::new().set_modified(modified))?;
+ }
+
+ let target = lookup_name(&config, "saved-session").await?;
+
+ assert_eq!(
+ (
+ target.map(|target| (target.path, target.thread_id)),
+ runtime
+ .get_thread(stale_id)
+ .await
+ .map_err(std::io::Error::other)?
+ .map(|metadata| metadata.title),
+ ),
+ (
+ Some((Some(fallback_path), fallback_id)),
+ Some("current-session".to_string()),
+ ),
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn keeps_newer_paginated_sqlite_name_when_index_is_stale() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let runtime = state_runtime(&config).await?;
+ let thread_id = ThreadId::new();
+ let rollout_path = write_rollout(
+ &config,
+ thread_id,
+ "2025-02-01T10:00:00Z",
+ "preview",
+ SessionSource::Cli,
+ ThreadHistoryMode::Paginated,
+ )?;
+ let mut metadata = thread_metadata(&config, thread_id, rollout_path, "preview text");
+ metadata.history_mode = ThreadHistoryMode::Paginated;
+ upsert_thread(&runtime, metadata).await?;
+ runtime
+ .update_thread_name(thread_id, Some("current-session"))
+ .await
+ .map_err(std::io::Error::other)?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), thread_id, "old-session")
+ .await?;
+
+ let target = lookup_name(&config, "old-session").await?;
+
+ assert_eq!(
+ (
+ target.map(|target| target.thread_id),
+ runtime
+ .get_thread(thread_id)
+ .await
+ .map_err(std::io::Error::other)?
+ .and_then(|metadata| metadata.name),
+ ),
+ (None, Some("current-session".to_string())),
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn prefers_most_recent_duplicate_legacy_name() -> color_eyre::Result<()> {
+ let temp_dir = TempDir::new()?;
+ let config = build_config(&temp_dir).await?;
+ let _runtime = state_runtime(&config).await?;
+ let recent_id = ThreadId::new();
+ let recent_path = write_rollout(
+ &config,
+ recent_id,
+ "2025-02-01T10:00:00Z",
+ "recent",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ let older_id = ThreadId::new();
+ let older_path = write_rollout(
+ &config,
+ older_id,
+ "2025-02-02T10:00:00Z",
+ "older",
+ SessionSource::Cli,
+ ThreadHistoryMode::Legacy,
+ )?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), recent_id, "same-name").await?;
+ codex_rollout::append_thread_name(config.codex_home.as_path(), older_id, "same-name").await?;
+ for (path, timestamp) in [
+ (&recent_path, "2025-02-04T10:00:00Z"),
+ (&older_path, "2025-02-03T10:00:00Z"),
+ ] {
+ let modified = chrono::DateTime::parse_from_rfc3339(timestamp)?.into();
+ std::fs::OpenOptions::new()
+ .append(true)
+ .open(path)?
+ .set_times(std::fs::FileTimes::new().set_modified(modified))?;
+ }
+
+ let target = lookup_name(&config, "same-name").await?;
+
+ assert_eq!(
+ target.map(|target| (target.path, target.thread_id)),
+ Some((Some(recent_path), recent_id)),
+ );
+ Ok(())
+}
diff --git a/codex-rs/tui/src/session_archive_commands.rs b/codex-rs/tui/src/session_archive_commands.rs
index faa4e78e76..e2c378f917 100644
--- a/codex-rs/tui/src/session_archive_commands.rs
+++ b/codex-rs/tui/src/session_archive_commands.rs
@@ -17,9 +17,10 @@ use crate::legacy_core::config::bootstrap_auth_config;
use crate::legacy_core::config::load_config_toml_with_layer_stack;
use crate::legacy_core::config::resolve_oss_provider;
use crate::legacy_core::config::resolve_profile_v2_config_path;
+use crate::named_session_lookup::NamedSessionCandidates;
+use crate::named_session_lookup::SessionCollection;
+use crate::named_session_lookup::SessionNameLookupMode;
use codex_app_server_protocol::Thread as AppServerThread;
-use codex_app_server_protocol::ThreadListParams;
-use codex_app_server_protocol::ThreadSortKey;
use codex_arg0::Arg0DispatchPaths;
use codex_cloud_config::cloud_config_bundle_loader_for_storage;
use codex_config::CloudConfigBundleLoader;
@@ -178,10 +179,9 @@ async fn lookup_session_by_exact_name(
name: &str,
archived: bool,
) -> Result<Option<AppServerThread>> {
- let uses_remote_workspace = app_server.uses_remote_workspace();
// Remote workspaces stay on their existing server-side path. Local workspaces trust SQLite
// names, then scan and repair only after a miss or an unusable rollout path.
- let lookup_modes = if uses_remote_workspace {
+ let lookup_modes = if app_server.uses_remote_workspace() {
&[SessionNameLookupMode::ScanAndRepair][..]
} else {
&[
@@ -190,87 +190,31 @@ async fn lookup_session_by_exact_name(
][..]
};
for &lookup_mode in lookup_modes {
- // Only the embedded server can safely use SQLite's recency cursor. Daemons may predate
- // that sort key, and filesystem repair must paginate in the scanner's mtime order.
- let sort_key = if lookup_mode == SessionNameLookupMode::StateDbOnly
- && app_server.uses_embedded_app_server()
- {
- ThreadSortKey::RecencyAt
- } else {
- ThreadSortKey::UpdatedAt
- };
// Search is the fast path, but legacy stores attach renamed titles after filtering.
for search_term in [Some(name), None] {
- let mut cursor = None;
- loop {
- let response = app_server
- .thread_list(ThreadListParams {
- cursor: cursor.clone(),
- limit: Some(100),
- sort_key: Some(sort_key),
- sort_direction: None,
- model_providers: None,
- source_kinds: Some(super::resume_source_kinds(
- /*include_non_interactive*/ false,
- )),
- archived: Some(archived),
- section_id: None,
- parent_thread_id: None,
- ancestor_thread_id: None,
- cwd: None,
- use_state_db_only: lookup_mode == SessionNameLookupMode::StateDbOnly,
- search_term: search_term.map(str::to_string),
- })
- .await
- .wrap_err("failed to list sessions while resolving session name")?;
-
- for thread in response
- .data
- .into_iter()
- .filter(|thread| thread.name.as_deref() == Some(name))
- {
- if !uses_remote_workspace {
- // The action still requires a real rollout in the requested collection.
- let thread_id = ThreadId::from_string(&thread.id).wrap_err_with(|| {
- format!("app server returned invalid session id `{}`", thread.id)
- })?;
- let expected_root = codex_home.join(if archived {
- codex_rollout::ARCHIVED_SESSIONS_SUBDIR
- } else {
- codex_rollout::SESSIONS_SUBDIR
- });
- let valid_rollout = if let Some(path) = thread.path.as_deref()
- && let Some(path) = codex_rollout::existing_rollout_path(path).await
- && path.starts_with(expected_root)
- && let Ok(session_meta) =
- codex_rollout::read_session_meta_line(path.as_path()).await
- {
- session_meta.meta.id == thread_id
- } else {
- false
- };
- if !valid_rollout {
- continue;
- }
- }
- return Ok(Some(thread));
- }
- let Some(next_cursor) = response.next_cursor else {
- break;
- };
- cursor = Some(next_cursor);
+ let mut candidates = NamedSessionCandidates::new(
+ name,
+ codex_home,
+ if archived {
+ SessionCollection::Archived
+ } else {
+ SessionCollection::Active
+ },
+ lookup_mode,
+ search_term,
+ );
+ if let Some(candidate) = candidates
+ .next(app_server)
+ .await
+ .wrap_err("failed to list sessions while resolving session name")?
+ {
+ return Ok(Some(candidate.thread));
}
}
}
Ok(None)
}
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum SessionNameLookupMode {
- StateDbOnly,
- ScanAndRepair,
-}
-
fn session_target_from_app_server_thread(thread: AppServerThread) -> Result<ResolvedSessionTarget> {
let session_id = ThreadId::from_string(&thread.id)
.wrap_err_with(|| format!("app server returned invalid session id `{}`", thread.id))?;