Lightweight coding agent that runs in your terminal
Rust
Delete persisted message boards with their root threads (#47029)
jif73129716c28b
diff --git a/codex-rs/app-server/tests/suite/v2/thread_delete.rs b/codex-rs/app-server/tests/suite/v2/thread_delete.rsindex ceebbbf3db..f5ed2b139f 100644--- a/codex-rs/app-server/tests/suite/v2/thread_delete.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_delete.rs@@ -4,9 +4,12 @@ use app_test_support::TestAppServer;use app_test_support::create_fake_paginated_rollout;use app_test_support::create_fake_rollout;use app_test_support::create_mock_responses_server_repeating_assistant;+use app_test_support::create_mock_responses_server_sequence;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::JSONRPCError;use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::ThreadArchiveParams;+use codex_app_server_protocol::ThreadArchiveResponse;use codex_app_server_protocol::ThreadDeleteParams;use codex_app_server_protocol::ThreadDeleteResponse;use codex_app_server_protocol::ThreadDeletedNotification;@@ -16,14 +19,20 @@ use codex_app_server_protocol::ThreadResumeParams;use codex_app_server_protocol::ThreadResumeResponse;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;+use codex_app_server_protocol::TurnStartParams;+use codex_app_server_protocol::TurnStatus;+use codex_app_server_protocol::UserInput;use codex_core::find_thread_path_by_id_str;+use codex_features::Feature;use codex_protocol::ThreadId;use codex_protocol::protocol::HistoryPosition;use codex_state::DirectionalThreadSpawnEdgeStatus;use codex_state::SqliteConfig;use codex_state::StateRuntime;use codex_utils_absolute_path::test_support::PathExt;+use core_test_support::responses;use pretty_assertions::assert_eq;+use serde_json::json;use std::path::Path;use tempfile::TempDir;use tokio::time::timeout;@@ -334,3 +343,92 @@ async fn thread_delete_handles_live_threads_before_rollout_exists() -> Result<()Ok(())}++#[tokio::test]+async fn thread_delete_removes_persisted_board_even_with_feature_disabled() -> Result<()> {+ let server = create_mock_responses_server_sequence(vec![+ responses::sse(vec![+ responses::ev_function_call_with_namespace(+ "post",+ "collaboration",+ "post",+ &json!({"new_channel_name":"design", "text":"Persist this decision"}).to_string(),+ ),+ responses::ev_completed("post"),+ ]),+ responses::sse(vec![+ responses::ev_assistant_message("done", "Done"),+ responses::ev_completed("done"),+ ]),+ ])+ .await;+ let home = TempDir::new()?;+ MockResponsesConfig::new(&server.uri())+ .enable_feature(Feature::AgentMessageBoard)+ .enable_feature(Feature::MultiAgentV2)+ .write(home.path())?;+ let mut app = TestAppServer::builder()+ .with_codex_home(home.path())+ .build_initialized()+ .await?;+ let thread = app.start_thread(ThreadStartParams::default()).await?.thread;+ let completed = app+ .start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "Post the decision".into(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ assert_eq!(completed.turn.status, TurnStatus::Completed);++ let sqlite = SqliteConfig::new_for_testing(home.path().abs());+ let pool = sqlite+ .open_read_only_pool(+ &sqlite.home().join("agent_message_board_1.sqlite"),+ /*busy_timeout*/ None,+ )+ .await?;+ assert_eq!(board_counts(&pool).await?, (1, 1, 1));+ let _: ThreadArchiveResponse = app+ .request(|request_id| ClientRequest::ThreadArchive {+ request_id,+ params: ThreadArchiveParams {+ thread_id: thread.id.clone(),+ },+ })+ .await?;+ app.shutdown_gracefully().await?;++ MockResponsesConfig::new(&server.uri())+ .disable_feature(Feature::AgentMessageBoard)+ .write(home.path())?;+ let mut app = TestAppServer::builder()+ .with_codex_home(home.path())+ .build_initialized()+ .await?;+ assert_eq!(board_counts(&pool).await?, (1, 1, 1));+ let _: ThreadDeleteResponse = app+ .request(|request_id| ClientRequest::ThreadDelete {+ request_id,+ params: ThreadDeleteParams {+ thread_id: thread.id,+ },+ })+ .await?;+ assert_eq!(board_counts(&pool).await?, (0, 0, 0));+ app.shutdown_gracefully().await?;+ Ok(())+}++async fn board_counts(pool: &sqlx::SqlitePool) -> Result<(i64, i64, i64)> {+ Ok(sqlx::query_as(+ "SELECT (SELECT COUNT(*) FROM channels),+ (SELECT COUNT(*) FROM posts),+ (SELECT COUNT(*) FROM subscriptions)",+ )+ .fetch_one(pool)+ .await?)+}diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rsindex 81d3cdb673..a0d7a8cdd0 100644--- a/codex-rs/core/src/thread_manager.rs+++ b/codex-rs/core/src/thread_manager.rs@@ -25,6 +25,7 @@ use crate::tasks::interrupted_turn_history_marker;use crate::thread_startup_metadata::ThreadStartupMetadata;use codex_agent_graph_store::AgentGraphStore;use codex_agent_graph_store::LocalAgentGraphStore;+use codex_agent_message_board_extension::LocalAgentMessageBoard;use codex_analytics::AnalyticsEventsClient;use codex_app_server_protocol::ThreadHistoryBuilder;use codex_app_server_protocol::TurnStatus;@@ -449,10 +450,23 @@ pub fn thread_store_from_config(.features.enabled(Feature::BackgroundPaginatedRolloutMigration);let has_state_db = state_db.is_some();- let store = Arc::new(LocalThreadStore::new(- LocalThreadStoreConfig::from_config(config),- state_db,- ));+ let sqlite = config.sqlite_config().clone();+ let store = Arc::new(+ LocalThreadStore::new(LocalThreadStoreConfig::from_config(config), state_db)+ .with_thread_data_cleanup(move |thread_ids| {+ let sqlite = sqlite.clone();+ Box::pin(async move {+ let boards = thread_ids.into_iter().map(Into::into).collect::<Vec<_>>();+ LocalAgentMessageBoard::delete_boards(&sqlite, &boards)+ .await+ .map_err(|err| ThreadStoreError::Internal {+ message: format!(+ "failed to delete agent message boards: {err}"+ ),+ })+ })+ }),+ );if has_state_db && background_migration_enabled {let startup_store = Arc::clone(&store);let codex_home = config.codex_home.to_path_buf();diff --git a/codex-rs/ext/agent-message-board/src/local.rs b/codex-rs/ext/agent-message-board/src/local.rsindex 4af7f0b6ab..0dbdac0640 100644--- a/codex-rs/ext/agent-message-board/src/local.rs+++ b/codex-rs/ext/agent-message-board/src/local.rs@@ -1,7 +1,8 @@//! SQLite-backed boards. The tree ID scopes every read and write.//!//! Immediate transactions serialize mutations across independently opened handles.-//! Accepted posts survive runtime unload and process restart.+//! Accepted posts survive runtime unload and process restart, but cannot recreate+//! a board after its root has been permanently deleted.use crate::ChannelSummary;use crate::CreateChannelRequest;@@ -34,14 +35,17 @@ use std::collections::HashSet;use std::sync::Arc;use uuid::Uuid;+mod lifecycle;mod paging;mod queries;const MAX_POST_BYTES: usize = 64 * 1024;const MAX_CHANNEL_BYTES: usize = 128;const MAX_READ_CHARS: usize = 20_000;+const DATABASE_FILE: &str = "agent_message_board_1.sqlite";const SCHEMA: &str = "+CREATE TABLE IF NOT EXISTS deleted_boards (board TEXT PRIMARY KEY NOT NULL);CREATE TABLE IF NOT EXISTS channels (board TEXT NOT NULL, name TEXT NOT NULL, name_search TEXT NOT NULL, created_at TEXT NOT NULL, timestamp INTEGER NOT NULL, author TEXT NOT NULL,PRIMARY KEY(board,name)@@ -86,7 +90,7 @@ impl LocalAgentMessageBoard {) -> Result<Self> {tokio::fs::create_dir_all(sqlite.home()).await?;let pool = sqlite- .open_read_write_pool(&sqlite.home().join("agent_message_board_1.sqlite"))+ .open_read_write_pool(&sqlite.home().join(DATABASE_FILE)).await.map_err(storage_error)?;sqlx::raw_sql(SCHEMA)@@ -108,11 +112,7 @@ impl LocalAgentMessageBoard {validate_channel(&request.channel_name)?;let author = self.host.agent_path(caller).await?;let now = self.host.current_time(caller).await?;- let mut tx = self- .pool- .begin_with("BEGIN IMMEDIATE")- .await- .map_err(storage_error)?;+ let mut tx = self.begin_write().await?;self.insert_channel(&mut tx, &request.channel_name, &author, now).await?;if request.subscription == SubscriptionChange::Subscribe {@@ -166,11 +166,7 @@ impl LocalAgentMessageBoard {recipients.insert(self.host.resolve_agent(path.clone()).await?);}let now = self.host.current_time(caller).await?;- let mut tx = self- .pool- .begin_with("BEGIN IMMEDIATE")- .await- .map_err(storage_error)?;+ let mut tx = self.begin_write().await?;if let Some(post) = self.existing_post(&mut tx, &request_id, &request_json).await?@@ -270,11 +266,7 @@ impl LocalAgentMessageBoard {let caller_path = self.host.agent_path(caller).await?;let target_path = request.target_agent.unwrap_or(caller_path);let target_agent = self.host.resolve_agent(target_path.clone()).await?;- let mut tx = self- .pool- .begin_with("BEGIN IMMEDIATE")- .await- .map_err(storage_error)?;+ let mut tx = self.begin_write().await?;let (channel, root, last) = match &request.target {SubscriptionTarget::Channel(name) => {let summary = self.channel_summary(&mut tx, name).await?;diff --git a/codex-rs/ext/agent-message-board/src/local/lifecycle.rs b/codex-rs/ext/agent-message-board/src/local/lifecycle.rsnew file mode 100644index 0000000000..45779c875c--- /dev/null+++ b/codex-rs/ext/agent-message-board/src/local/lifecycle.rs@@ -0,0 +1,80 @@+//! Permanent board deletion, serialized with writes across all open handles.+//!+//! Keep only a root ID tombstone so delayed writes cannot resurrect deleted data.++use super::DATABASE_FILE;+use super::LocalAgentMessageBoard;+use super::SCHEMA;+use super::invalid;+use super::storage_error;+use codex_protocol::SessionId;+use codex_protocol::error::Result;+use codex_state::SqliteConfig;+use sqlx::Sqlite;+use sqlx::Transaction;++impl LocalAgentMessageBoard {+ /// Permanently removes boards owned by these roots, including their posts and subscriptions.+ /// A child's ID does not match its parent's board. Unload and archive must not call this.+ /// Safe to retry and independent of whether the feature is currently enabled.+ pub async fn delete_boards(sqlite: &SqliteConfig, roots: &[SessionId]) -> Result<()> {+ let path = sqlite.home().join(DATABASE_FILE);+ if roots.is_empty() || !tokio::fs::try_exists(&path).await? {+ return Ok(());+ }+ let pool = sqlite+ .open_read_write_pool(&path)+ .await+ .map_err(storage_error)?;+ // Also handles databases created before permanent deletion was supported.+ sqlx::raw_sql(SCHEMA)+ .execute(&pool)+ .await+ .map_err(storage_error)?;+ let mut tx = pool+ .begin_with("BEGIN IMMEDIATE")+ .await+ .map_err(storage_error)?;+ for root in roots {+ sqlx::query("INSERT OR IGNORE INTO deleted_boards (board) VALUES (?)")+ .bind(root.to_string())+ .execute(&mut *tx)+ .await+ .map_err(storage_error)?;+ for statement in [+ "DELETE FROM subscriptions WHERE board=?",+ "DELETE FROM posts WHERE board=?",+ "DELETE FROM channels WHERE board=?",+ ] {+ sqlx::query(statement)+ .bind(root.to_string())+ .execute(&mut *tx)+ .await+ .map_err(storage_error)?;+ }+ }+ tx.commit().await.map_err(storage_error)?;+ pool.close().await;+ Ok(())+ }++ pub(super) async fn begin_write(&self) -> Result<Transaction<'_, Sqlite>> {+ let mut tx = self+ .pool+ .begin_with("BEGIN IMMEDIATE")+ .await+ .map_err(storage_error)?;+ let deleted: bool =+ sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM deleted_boards WHERE board=?)")+ .bind(self.identity.to_string())+ .fetch_one(&mut *tx)+ .await+ .map_err(storage_error)?;+ if deleted {+ return Err(invalid(+ "the message board's root has been permanently deleted",+ ));+ }+ Ok(tx)+ }+}diff --git a/codex-rs/thread-store/src/local/delete_thread.rs b/codex-rs/thread-store/src/local/delete_thread.rsindex 775344a783..103b12d49f 100644--- a/codex-rs/thread-store/src/local/delete_thread.rs+++ b/codex-rs/thread-store/src/local/delete_thread.rs@@ -3,7 +3,8 @@//! Existing rollout files are deleted before this operation reports success. A rollout file that//! vanishes after discovery counts as already deleted. Main state DB rows are deleted after every//! associated rollout is removed, under the same lifecycle lock, so queued artifact mutations cannot-//! use deleted thread metadata.+//! use deleted thread metadata. Host-owned data is cleaned after reference and writer checks,+//! before removing rollouts, so cleanup failures remain retryable even without a state DB.use std::collections::HashMap;use std::collections::HashSet;@@ -73,6 +74,9 @@ pub(super) async fn delete_thread(let thread_rollouts = ThreadRollouts::from_index(&reference_index, thread_id);ensure_no_external_references(&reference_index, std::slice::from_ref(&thread_rollouts))?;let mut writer_guards = store.acquire_writer_locks(&[thread_id]).await?;+ if let Some(cleanup) = &store.thread_data_cleanup {+ cleanup(vec![thread_id]).await?;+ }let found_rollout =match delete_thread_after_reference_check(store, thread_rollouts, &mut writer_guards).await{@@ -117,6 +121,9 @@ pub(super) async fn delete_threads(ensure_no_external_references(&reference_index, thread_rollouts.as_slice())?;let mut writer_guards = store.acquire_writer_locks(&lock_thread_ids).await?;+ if let Some(cleanup) = &store.thread_data_cleanup {+ cleanup(thread_ids.clone()).await?;+ }for thread_rollouts in thread_rollouts {match delete_thread_after_reference_check(store, thread_rollouts, &mut writer_guards).await{diff --git a/codex-rs/thread-store/src/local/mod.rs b/codex-rs/thread-store/src/local/mod.rsindex 0e170c2439..3bc268268a 100644--- a/codex-rs/thread-store/src/local/mod.rs+++ b/codex-rs/thread-store/src/local/mod.rs@@ -142,8 +142,11 @@ pub struct LocalThreadStore {writer_lock_coordinator: Arc<WriterLockCoordinator>,state_db: Option<StateDbHandle>,thread_history_db: Arc<OnceCell<sqlx::SqlitePool>>,+ thread_data_cleanup: Option<Arc<ThreadDataCleanup>>,}+type ThreadDataCleanup = dyn Fn(Vec<ThreadId>) -> ThreadStoreFuture<'static, ()> + Send + Sync;+type WriterLockGuard = Arc<codex_rollout::WriterLockGuard>;struct LiveRecorderEntry {@@ -257,9 +260,21 @@ impl LocalThreadStore {writer_lock_coordinator,state_db,thread_history_db: Arc::new(OnceCell::new()),+ thread_data_cleanup: None,}}+ /// Adds cleanup for host-owned durable data when threads are permanently deleted.+ /// Runs after reference and writer checks, under the lifecycle locks, before deleting rollouts.+ /// Cleanup must be idempotent: later deletion steps can fail and the caller may retry.+ pub fn with_thread_data_cleanup(+ mut self,+ cleanup: impl Fn(Vec<ThreadId>) -> ThreadStoreFuture<'static, ()> + Send + Sync + 'static,+ ) -> Self {+ self.thread_data_cleanup = Some(Arc::new(cleanup));+ self+ }+/// Return the state DB handle used by local rollout writers.pub async fn state_db(&self) -> Option<StateDbHandle> {self.state_db.clone()