Lightweight coding agent that runs in your terminal
Rust
Prefer SQLite names for local session archive commands (#36808)
Charlie Marsh9c8f9ce8975b
diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex 67401985cd..490122d053 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -2222,7 +2222,7 @@ mod tests {Ok(())}- async fn start_test_embedded_app_server(+ pub(crate) async fn start_test_embedded_app_server(config: Config,) -> color_eyre::Result<InProcessAppServerClient> {let state_db =diff --git a/codex-rs/tui/src/session_archive_commands.rs b/codex-rs/tui/src/session_archive_commands.rsindex 1dea0ffe0f..ddf82f7461 100644--- a/codex-rs/tui/src/session_archive_commands.rs+++ b/codex-rs/tui/src/session_archive_commands.rs@@ -5,6 +5,8 @@use std::io::IsTerminal;use std::io::Write;+use std::path::Path;+use std::path::PathBuf;use std::sync::Arc;use crate::Cli;@@ -82,16 +84,25 @@ pub async fn run_session_archive_command(target: String,options: SessionArchiveCommandOptions,) -> Result<String> {- let mut app_server = start_app_server_for_archive_command(options).await?;- run_session_archive_action_with_app_server(&mut app_server, action, &target).await+ let codex_home = find_codex_home().wrap_err("failed to find Codex home")?;+ let mut app_server =+ start_app_server_for_archive_command(options, codex_home.to_path_buf()).await?;+ run_session_archive_action_with_app_server(+ &mut app_server,+ codex_home.as_path(),+ action,+ &target,+ )+ .await}async fn run_session_archive_action_with_app_server(app_server: &mut AppServerSession,+ codex_home: &Path,action: SessionArchiveAction,target: &str,) -> Result<String> {- let resolved = resolve_session_target(app_server, action, target).await?;+ let resolved = resolve_session_target(app_server, codex_home, action, target).await?;let session_name = match action {SessionArchiveAction::Archive => {app_server.thread_archive(resolved.session_id).await?;@@ -120,6 +131,7 @@ async fn run_session_archive_action_with_app_server(async fn resolve_session_target(app_server: &mut AppServerSession,+ codex_home: &Path,action: SessionArchiveAction,target: &str,) -> Result<ResolvedSessionTarget> {@@ -151,7 +163,9 @@ async fn resolve_session_target(SessionArchiveAction::Unarchive => ("archived", &[true]),};for &archived in archived_values {- if let Some(thread) = lookup_session_by_exact_name(app_server, target, archived).await? {+ if let Some(thread) =+ lookup_session_by_exact_name(app_server, codex_home, target, archived).await?+ {return session_target_from_app_server_thread(thread);}}@@ -162,50 +176,103 @@ async fn resolve_session_target(async fn lookup_session_by_exact_name(app_server: &mut AppServerSession,+ codex_home: &Path,name: &str,archived: bool,) -> Result<Option<AppServerThread>> {- // Search is the fast path, but some stores attach renamed titles after applying the filter.- 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(ThreadSortKey::UpdatedAt),- 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: false,- search_term: search_term.map(str::to_string),- })- .await- .wrap_err("failed to list sessions while resolving session name")?;+ 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 {+ &[SessionNameLookupMode::ScanAndRepair][..]+ } else {+ &[+ SessionNameLookupMode::StateDbOnly,+ SessionNameLookupMode::ScanAndRepair,+ ][..]+ };+ 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")?;- if let Some(thread) = response- .data- .into_iter()- .find(|thread| thread.name.as_deref() == Some(name))- {- return Ok(Some(thread));+ 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 Some(next_cursor) = response.next_cursor else {- break;- };- cursor = Some(next_cursor);}}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))?;@@ -246,6 +313,7 @@ fn confirm_session_delete(target: &ResolvedSessionTarget) -> Result<bool> {async fn start_app_server_for_archive_command(options: SessionArchiveCommandOptions,+ codex_home: PathBuf,) -> Result<AppServerSession> {let SessionArchiveCommandOptions {cli,@@ -259,8 +327,6 @@ async fn start_app_server_for_archive_command(let cli_kv_overrides = overrides_cli.parse_overrides().map_err(|err| eyre!("failed to parse -c overrides: {err}"))?;- let codex_home = find_codex_home().wrap_err("failed to find Codex home")?;-let mut launch_loader_overrides = loader_overrides.clone();if let Some(profile_v2) = cli.config_profile_v2.as_ref() {launch_loader_overrides.user_config_path = Some(resolve_profile_v2_config_path(@@ -413,3 +479,7 @@ async fn start_app_server_for_archive_command(.with_remote_cwd_override(remote_cwd_override),)}++#[cfg(test)]+#[path = "session_archive_commands_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/session_archive_commands_tests.rs b/codex-rs/tui/src/session_archive_commands_tests.rsnew file mode 100644index 0000000000..351247a651--- /dev/null+++ b/codex-rs/tui/src/session_archive_commands_tests.rs@@ -0,0 +1,373 @@+use std::path::PathBuf;+use std::sync::Arc;++use chrono::DateTime;+use chrono::Utc;+use codex_protocol::ThreadId;+use codex_protocol::protocol::SessionMeta;+use codex_protocol::protocol::SessionMetaLine;+use codex_protocol::protocol::SessionSource;+use codex_state::ThreadMetadataBuilder;+use codex_utils_absolute_path::test_support::PathExt;+use pretty_assertions::assert_eq;+use tempfile::TempDir;++use super::DeleteConfirmation;+use super::SessionArchiveAction;+use super::run_session_archive_action_with_app_server;+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 start_app_server(config: Config) -> color_eyre::Result<AppServerSession> {+ Ok(AppServerSession::new(+ codex_app_server_client::AppServerClient::InProcess(+ start_test_embedded_app_server(config).await?,+ ),+ ThreadParamsMode::Embedded,+ ))+}++fn write_rollout(+ config: &Config,+ thread_id: ThreadId,+ archived: bool,+ timestamp: &str,+ preview: &str,+) -> color_eyre::Result<PathBuf> {+ let subdir = if archived {+ "archived_sessions"+ } else {+ "sessions/2025/02/01"+ };+ let rollout_path = config+ .codex_home+ .join(subdir)+ .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: SessionSource::Cli,+ model_provider: Some(config.model_provider_id.clone()),+ ..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}],+ },+ }),+ serde_json::json!({+ "timestamp": timestamp,+ "type": "event_msg",+ "payload": {+ "type": "user_message",+ "message": preview,+ "kind": "plain",+ },+ }),+ ];+ std::fs::write(+ &rollout_path,+ lines+ .iter()+ .map(serde_json::Value::to_string)+ .collect::<Vec<_>>()+ .join("\n")+ + "\n",+ )?;+ Ok(rollout_path.to_path_buf())+}++fn thread_metadata(+ config: &Config,+ thread_id: ThreadId,+ rollout_path: PathBuf,+ name: &str,+ archived: bool,+) -> codex_state::ThreadMetadata {+ let created_at = DateTime::parse_from_rfc3339("2025-02-01T10:00:00Z")+ .expect("timestamp should parse")+ .with_timezone(&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 = name.to_string();+ metadata.first_user_message = Some("preview text".to_string());+ metadata.preview = metadata.first_user_message.clone();+ metadata.archived_at = archived.then_some(created_at);+ metadata+}++#[tokio::test]+async fn archives_by_sqlite_name() -> 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,+ /*archived*/ false,+ "2025-02-01T10:00:00Z",+ "preview",+ )?;+ runtime+ .upsert_thread(&thread_metadata(+ &config,+ thread_id,+ rollout_path,+ "saved-session",+ /*archived*/ false,+ ))+ .await+ .map_err(std::io::Error::other)?;++ let mut app_server = start_app_server(config.clone()).await?;+ let message = run_session_archive_action_with_app_server(+ &mut app_server,+ config.codex_home.as_path(),+ SessionArchiveAction::Archive,+ "saved-session",+ )+ .await?;+ app_server.shutdown().await?;++ assert_eq!(+ (+ message,+ runtime+ .get_thread(thread_id)+ .await+ .map_err(std::io::Error::other)?+ .is_some_and(|metadata| metadata.archived_at.is_some()),+ ),+ (+ format!("Archived session saved-session ({thread_id})."),+ true,+ ),+ );+ Ok(())+}++#[tokio::test]+async fn unarchives_by_sqlite_name() -> 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,+ /*archived*/ true,+ "2025-02-01T10:00:00Z",+ "preview",+ )?;+ runtime+ .upsert_thread(&thread_metadata(+ &config,+ thread_id,+ rollout_path,+ "saved-session",+ /*archived*/ true,+ ))+ .await+ .map_err(std::io::Error::other)?;++ let mut app_server = start_app_server(config.clone()).await?;+ let message = run_session_archive_action_with_app_server(+ &mut app_server,+ config.codex_home.as_path(),+ SessionArchiveAction::Unarchive,+ "saved-session",+ )+ .await?;+ app_server.shutdown().await?;++ assert_eq!(+ (+ message,+ runtime+ .get_thread(thread_id)+ .await+ .map_err(std::io::Error::other)?+ .is_some_and(|metadata| metadata.archived_at.is_some()),+ ),+ (+ format!("Unarchived session saved-session ({thread_id})."),+ false,+ ),+ );+ Ok(())+}++#[tokio::test]+async fn deletes_valid_duplicate_after_stale_sqlite_hit() -> 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_rollout_path = write_rollout(+ &config,+ stale_id,+ /*archived*/ true,+ "2025-02-01T10:00:00Z",+ "stale preview",+ )?;+ runtime+ .upsert_thread(&thread_metadata(+ &config,+ stale_id,+ stale_rollout_path.clone(),+ "saved-session",+ /*archived*/ false,+ ))+ .await+ .map_err(std::io::Error::other)?;++ let thread_id = ThreadId::new();+ let rollout_path = write_rollout(+ &config,+ thread_id,+ /*archived*/ false,+ "2025-02-01T10:00:00Z",+ "preview",+ )?;+ codex_rollout::append_thread_name(config.codex_home.as_path(), thread_id, "saved-session")+ .await?;++ let mut app_server = start_app_server(config.clone()).await?;+ let message = run_session_archive_action_with_app_server(+ &mut app_server,+ config.codex_home.as_path(),+ SessionArchiveAction::Delete(DeleteConfirmation::Skip),+ "saved-session",+ )+ .await?;+ app_server.shutdown().await?;++ assert_eq!(+ (+ message,+ rollout_path.exists(),+ stale_rollout_path.exists(),+ runtime+ .get_thread(thread_id)+ .await+ .map_err(std::io::Error::other)?,+ runtime+ .get_thread(stale_id)+ .await+ .map_err(std::io::Error::other)?+ .is_some(),+ ),+ (+ format!("Deleted session saved-session ({thread_id})."),+ false,+ true,+ None,+ true,+ ),+ );+ Ok(())+}++#[tokio::test]+async fn trusts_sqlite_name_over_legacy_index_for_delete() -> 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,+ /*archived*/ false,+ "2025-02-01T10:00:00Z",+ "preview",+ )?;+ runtime+ .upsert_thread(&thread_metadata(+ &config,+ thread_id,+ rollout_path.clone(),+ "new-session",+ /*archived*/ false,+ ))+ .await+ .map_err(std::io::Error::other)?;+ codex_rollout::append_thread_name(config.codex_home.as_path(), thread_id, "old-session")+ .await?;++ let mut app_server = start_app_server(config.clone()).await?;+ let message = run_session_archive_action_with_app_server(+ &mut app_server,+ config.codex_home.as_path(),+ SessionArchiveAction::Delete(DeleteConfirmation::Skip),+ "new-session",+ )+ .await?;+ app_server.shutdown().await?;++ assert_eq!(+ (+ message,+ rollout_path.exists(),+ runtime+ .get_thread(thread_id)+ .await+ .map_err(std::io::Error::other)?,+ ),+ (+ format!("Deleted session new-session ({thread_id})."),+ false,+ None,+ ),+ );+ Ok(())+}