diff --git a/codex-rs/ext/guardian-v3/src/evidence.rs b/codex-rs/ext/guardian-v3/src/evidence.rs index 0fe29445bd..a93d587aae 100644 --- a/codex-rs/ext/guardian-v3/src/evidence.rs +++ b/codex-rs/ext/guardian-v3/src/evidence.rs @@ -20,7 +20,6 @@ use codex_thread_store::ThreadStoreResult; use codex_utils_string::to_json_string_bounded; use serde::Deserialize; use serde::Serialize; -use std::sync::Arc; /// Position in the containing snapshot's root history, independent of channel routing. #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)] @@ -50,13 +49,11 @@ pub struct OriginalEvidence { } /// An immutable capture. Later history appends cannot enter its reads or routing. -/// Clones share the captured records rather than copying message payloads. -#[derive(Clone)] pub struct EvidenceSnapshot { thread_id: ThreadId, start: HistoryPosition, end: HistoryPosition, - records: Arc<[OriginalEvidence]>, + records: Vec, // Report these positions only when the intake cursor accepts this capture. pub(super) skipped_incomplete_deliveries: Vec, } @@ -179,7 +176,7 @@ impl EvidenceCursor { thread_id: self.thread_id, start: self.position, end, - records: records.into(), + records, skipped_incomplete_deliveries, }) } diff --git a/codex-rs/ext/guardian-v3/tests/housekeeping.rs b/codex-rs/ext/guardian-v3/tests/housekeeping.rs index e1d46418b7..531abb8bb0 100644 --- a/codex-rs/ext/guardian-v3/tests/housekeeping.rs +++ b/codex-rs/ext/guardian-v3/tests/housekeeping.rs @@ -463,9 +463,19 @@ async fn routes_captured_originals_and_updates_descriptions( json!({"catalog":catalog,"sources":[source]}) ); } - let view = board.read_view(owner).await?; - let release = view - .channels() + let catalog = board + .list_channels( + owner, + ChannelQuery { + query: Some("release".into()), + direction: SortDirection::OldestFirst, + page: PageRequest::default(), + }, + ) + .await?; + let release = catalog + .channels + .results .iter() .find(|channel| channel.channel_name == "release"); assert_eq!( diff --git a/codex-rs/message-board/src/api.rs b/codex-rs/message-board/src/api.rs index dcae419a4b..a53fab28fa 100644 --- a/codex-rs/message-board/src/api.rs +++ b/codex-rs/message-board/src/api.rs @@ -1,7 +1,6 @@ //! Operations on one board. Requests describe intent independently of tool schemas. //! Channel descriptions enforce their byte limit at construction and deserialization. -use crate::BoardReadView; use crate::ChannelPage; use crate::ChannelSummary; use crate::Page; @@ -19,7 +18,6 @@ use codex_protocol::error::Result; use futures::future::BoxFuture; use serde::Deserialize; use serde::Serialize; -use std::collections::BTreeMap; use std::num::NonZeroU32; use std::sync::Arc; use uuid::Uuid; @@ -55,11 +53,6 @@ pub trait AgentMessageBoard: Send + Sync { )) } - /// Capture a live board's channel summaries and post boundary together for read-only access. - fn read_view(&self, _caller: ThreadId) -> BoxFuture<'_, Result>> { - unsupported("capturing a board read view") - } - fn create_channel( &self, caller: ThreadId, @@ -158,16 +151,6 @@ pub trait AgentMessageBoard: Send + Sync { ) -> BoxFuture<'_, Result>> { unsupported("listing channel subscriptions") } - - /// Set the caller's membership in the supplied channels as one atomic change. - /// Other channels and thread subscriptions retain their current membership. - fn set_subscriptions<'a>( - &'a self, - _caller: ThreadId, - _channels: &'a BTreeMap<&str, SubscriptionChange>, - ) -> BoxFuture<'a, Result<()>> { - unsupported("setting channel subscriptions in bulk") - } } fn unsupported(operation: &'static str) -> BoxFuture<'static, Result> { diff --git a/codex-rs/message-board/src/lib.rs b/codex-rs/message-board/src/lib.rs index d76eb69802..690e4620b5 100644 --- a/codex-rs/message-board/src/lib.rs +++ b/codex-rs/message-board/src/lib.rs @@ -8,7 +8,6 @@ mod host; mod in_memory; mod local; mod permissions; -mod read_view; mod tools; mod types; @@ -43,10 +42,8 @@ pub use local::setup::configure_local_board; pub use permissions::BoardPermissions; pub use permissions::ChannelPermissions; pub use permissions::PermissionDenied; -pub use read_view::BoardReadView; pub use tools::MAX_TOOL_ARGUMENT_KIB; pub use tools::MAX_TOOL_RESPONSE_BYTES; -pub use tools::message_board_read_tools; pub use tools::message_board_tools; pub use tools::selection::MessageBoardTool; pub use types::ChannelPage; diff --git a/codex-rs/message-board/src/local.rs b/codex-rs/message-board/src/local.rs index 8bf0e5cc28..194a6b45d6 100644 --- a/codex-rs/message-board/src/local.rs +++ b/codex-rs/message-board/src/local.rs @@ -6,7 +6,6 @@ //! a board after its root has been permanently deleted. //! Opening storage adds optional channel metadata without invalidating older readers. //! Explicit connections can restrict writes; default handles retain legacy access. -//! Fixed read views freeze the channel catalog and restrict reads to a captured post sequence. //! Posting subscribes and notifies; host appends share persistence without these side effects. use self::connection::Access; @@ -62,38 +61,13 @@ const MAX_POST_BYTES: usize = 64 * 1024; const MAX_CHANNEL_BYTES: usize = 128; const MAX_READ_CHARS: usize = 20_000; -/// Capturing a view makes the handle read-only, regardless of its original access. -#[derive(Clone)] -enum BoardMode { - Live { access: Option }, - Fixed { view: Arc }, -} - -impl BoardMode { - const FIXED_ACCESS: Access = Access::ReadOnly; - - fn access(&self) -> Option { - match self { - Self::Live { access } => *access, - Self::Fixed { .. } => Some(Self::FIXED_ACCESS), - } - } - - fn view(&self) -> Option<&catalog::ReadView> { - match self { - Self::Live { .. } => None, - Self::Fixed { view } => Some(view), - } - } -} - #[derive(Clone)] pub struct LocalAgentMessageBoard { identity: SessionId, storage_namespace: Arc, pool: Arc, host: Arc, - mode: BoardMode, + access: Option, nested_json_pointer: Option<&'static str>, } @@ -118,7 +92,7 @@ impl LocalAgentMessageBoard { pool: pool::open(sqlite, options).await?, storage_namespace: Arc::from(options.storage_namespace.as_str()), host, - mode: BoardMode::Live { access: None }, + access: None, nested_json_pointer: None, }) } @@ -128,7 +102,7 @@ impl LocalAgentMessageBoard { caller: ThreadId, request: CreateChannelRequest, ) -> Result { - if let Some(access) = self.mode.access() { + if let Some(access) = self.access { access.require_write(self.identity, "board.create_channel")?; } validate_channel(&request.channel_name)?; @@ -203,7 +177,7 @@ impl LocalAgentMessageBoard { request: PostRequest, behavior: PostBehavior, ) -> Result<(PostMetadata, Vec)> { - if let Some(access) = self.mode.access() { + if let Some(access) = self.access { access.require_write( self.identity, match &request.destination { @@ -392,7 +366,7 @@ impl LocalAgentMessageBoard { let target_path = request.target_agent.unwrap_or(caller_path); let target_agent = self.host.resolve_agent(target_path.clone()).await?; if target_agent != caller - && let Some(access) = self.mode.access() + && let Some(access) = self.access { access.require_write(self.identity, "board.manage_subscriptions")?; } diff --git a/codex-rs/message-board/src/local/catalog.rs b/codex-rs/message-board/src/local/catalog.rs index 3e9da655c7..b46e4a896a 100644 --- a/codex-rs/message-board/src/local/catalog.rs +++ b/codex-rs/message-board/src/local/catalog.rs @@ -1,236 +1,19 @@ -//! Channel summaries and fixed read views. Capture only catalog metadata and a -//! monotonically increasing post boundary; payload reads continue to use SQLite. +//! Read channel metadata and permissions for a local board. -use super::BoardMode; use super::LocalAgentMessageBoard; use super::connection::Access; use super::invalid; -use super::paging::Window; use super::storage_error; -use crate::AgentMessageBoard; -use crate::BoardPermissions; -use crate::BoardReadView; -use crate::ChannelPage; use crate::ChannelPermissions; -use crate::ChannelQuery; use crate::ChannelSummary; -use crate::Page; -use crate::PostContent; -use crate::PostPreview; -use crate::PostQuery; -use crate::ReadPostRequest; -use crate::ReadThreadRequest; -use crate::SortDirection; -use crate::ThreadPage; -use crate::ThreadQuery; -use crate::ThreadSummary; -use caseless::default_case_fold_str; use chrono::DateTime; use chrono::Utc; use codex_protocol::AgentPath; -use codex_protocol::SessionId; -use codex_protocol::ThreadId; use codex_protocol::error::Result; -use futures::future::BoxFuture; use sqlx::Row; use sqlx::SqliteConnection; -use sqlx::sqlite::SqliteRow; -use std::sync::Arc; use uuid::Uuid; -/// The captured catalog and the read-only SQLite handle that enforces its post boundary. -struct LocalBoardReadView { - board: LocalAgentMessageBoard, - view: Arc, -} - -impl BoardReadView for LocalBoardReadView { - fn identity(&self) -> SessionId { - self.board.identity - } - - fn with_json_search(&self, pointer: &'static str) -> Arc { - let mut board = self.board.clone(); - board.nested_json_pointer = Some(pointer); - Arc::new(Self { - board, - view: Arc::clone(&self.view), - }) - } - - fn storage_namespace(&self) -> &str { - &self.board.storage_namespace - } - - fn channels(&self) -> &[ChannelSummary] { - &self.view.channels - } - - fn list_channels( - &self, - caller: ThreadId, - query: ChannelQuery, - ) -> BoxFuture<'_, Result> { - self.board.list_channels(caller, query) - } - - fn list_threads( - &self, - caller: ThreadId, - query: ThreadQuery, - ) -> BoxFuture<'_, Result>> { - self.board.list_threads(caller, query) - } - - fn search_posts( - &self, - caller: ThreadId, - query: PostQuery, - ) -> BoxFuture<'_, Result>> { - self.board.search_posts(caller, query) - } - - fn read_thread( - &self, - caller: ThreadId, - request: ReadThreadRequest, - ) -> BoxFuture<'_, Result> { - self.board.read_thread(caller, request) - } - - fn read_post( - &self, - caller: ThreadId, - request: ReadPostRequest, - ) -> BoxFuture<'_, Result> { - AgentMessageBoard::read_post(&self.board, caller, request) - } - - fn appended_request_ids<'a>( - &'a self, - caller: ThreadId, - channel: &'a str, - after: i64, - ) -> BoxFuture<'a, Result>> { - Box::pin(async move { - self.board.host.agent_path(caller).await?; - if after < 0 || after > self.view.post_cutoff { - return Err(invalid("post cursor is outside the captured board view")); - } - // The persisted retry key prefixes the caller-supplied request ID with "{caller}:". - sqlx::query_as( - "SELECT seq, substr(request_id, instr(request_id, ':') + 1) FROM posts - WHERE board=? AND channel=? AND seq>? AND seq<=? ORDER BY seq LIMIT ?", - ) - .bind(self.board.identity.to_string()) - .bind(channel) - .bind(after) - .bind(self.view.post_cutoff) - .bind(i64::from(crate::PageRequest::default().limit.get())) - .fetch_all(self.board.pool.as_ref()) - .await - .map_err(storage_error) - }) - } - - fn read_post_texts<'a>( - &'a self, - caller: ThreadId, - positions: &'a [i64], - ) -> BoxFuture<'a, Result>> { - Box::pin(async move { - self.board.host.agent_path(caller).await?; - if positions.len() > crate::PageRequest::default().limit.get() as usize { - return Err(invalid("requested posts exceed one board page")); - } - // Drive primary-key lookups from the requested page, not from all posts on the board. - let texts = sqlx::query_scalar::<_, String>( - "SELECT json_extract(p.payload, '$.text') FROM json_each(?) AS requested - CROSS JOIN posts AS p - WHERE p.seq=requested.value AND p.board=? AND p.seq<=? ORDER BY requested.key", - ) - .bind(serde_json::to_string(positions).map_err(storage_error)?) - .bind(self.board.identity.to_string()) - .bind(self.view.post_cutoff) - .fetch_all(self.board.pool.as_ref()) - .await - .map_err(storage_error)?; - if texts.len() != positions.len() { - return Err(invalid("post not found in this board view")); - } - Ok(texts) - }) - } -} - -pub(super) struct ReadView { - pub(super) post_cutoff: i64, - pub(super) channels: Vec, -} - -impl ReadView { - pub(super) fn list_channels(&self, query: ChannelQuery) -> Result { - let window = Window::new(&query.page)?; - let needle = default_case_fold_str(&query.query.unwrap_or_default()); - let ordered: Box> = match query.direction { - SortDirection::NewestFirst => Box::new(self.channels.iter()), - SortDirection::OldestFirst => Box::new(self.channels.iter().rev()), - }; - let channels = ordered - .filter(|channel| default_case_fold_str(&channel.channel_name).contains(&needle)) - .skip(window.offset() as usize) - .take(window.limit + 1) - .cloned() - .collect(); - Ok(ChannelPage { - channels: window.finish(channels)?, - board_permissions: Some(BoardPermissions { - create_channel: false, - edit_metadata: false, - manage_permissions: false, - }), - }) - } -} - -pub(super) async fn capture(board: &LocalAgentMessageBoard) -> Result> { - let mut tx = board.pool.begin().await.map_err(storage_error)?; - // seq is the database-wide AUTOINCREMENT key. Every future board append is above it. - let post_cutoff = sqlx::query_scalar::<_, i64>("SELECT COALESCE(MAX(seq),0) FROM posts") - .fetch_one(&mut *tx) - .await - .map_err(storage_error)?; - let rows = sqlx::query( - "SELECT c.name,c.created_at,c.author,c.description,last.id AS last_message_id, - (SELECT COUNT(*) FROM posts p WHERE p.board=c.board AND p.channel=c.name) AS message_count - FROM channels c LEFT JOIN posts last ON last.seq=( - SELECT p.seq FROM posts p WHERE p.board=c.board AND p.channel=c.name - ORDER BY p.timestamp DESC,p.seq DESC LIMIT 1 - ) - WHERE c.board=? ORDER BY COALESCE(last.timestamp,c.timestamp) DESC,c.name DESC", - ) - .bind(board.identity.to_string()) - .fetch_all(&mut *tx) - .await - .map_err(storage_error)?; - tx.commit().await.map_err(storage_error)?; - let channels = rows - .into_iter() - .map(|row| decode_channel_summary(Some(BoardMode::FIXED_ACCESS), row)) - .collect::>>()?; - let view = Arc::new(ReadView { - post_cutoff, - channels, - }); - let board = LocalAgentMessageBoard { - mode: BoardMode::Fixed { - view: Arc::clone(&view), - }, - ..board.clone() - }; - Ok(Arc::new(LocalBoardReadView { board, view })) -} - pub(super) async fn channel_summary( board: &LocalAgentMessageBoard, conn: &mut SqliteConnection, @@ -248,12 +31,8 @@ pub(super) async fn channel_summary( .await .map_err(storage_error)? .ok_or_else(|| invalid("channel not found in this board"))?; - decode_channel_summary(board.mode.access(), row) -} - -fn decode_channel_summary(access: Option, row: SqliteRow) -> Result { Ok(ChannelSummary { - permissions: access.map(|access| { + permissions: board.access.map(|access| { let write = matches!(access, Access::ReadWrite); ChannelPermissions { read: true, diff --git a/codex-rs/message-board/src/local/connection.rs b/codex-rs/message-board/src/local/connection.rs index 6ceff4f749..c79240be10 100644 --- a/codex-rs/message-board/src/local/connection.rs +++ b/codex-rs/message-board/src/local/connection.rs @@ -1,7 +1,6 @@ //! Host-supplied connections to one local board. Access is fixed per runtime, //! independent of the board's storage or the agent's tree identity. -use super::BoardMode; use super::LocalAgentMessageBoard; use super::options::LocalBoardOptions; use crate::MessageBoardHost; @@ -104,9 +103,7 @@ impl LocalBoardConnection { "board database changed; create a new board connection".into(), )); } - board.mode = BoardMode::Live { - access: Some(self.access), - }; + board.access = Some(self.access); Ok(board) } } diff --git a/codex-rs/message-board/src/local/json_search.rs b/codex-rs/message-board/src/local/json_search.rs index 3cef557565..6ec401e176 100644 --- a/codex-rs/message-board/src/local/json_search.rs +++ b/codex-rs/message-board/src/local/json_search.rs @@ -1,4 +1,4 @@ -//! Literal search over decoded JSON fields in a fixed read view. +//! Literal search over decoded JSON fields in board posts. use super::StoredPost; use super::paging::Window; diff --git a/codex-rs/message-board/src/local/paging.rs b/codex-rs/message-board/src/local/paging.rs index 3ee57448c3..8c956f3640 100644 --- a/codex-rs/message-board/src/local/paging.rs +++ b/codex-rs/message-board/src/local/paging.rs @@ -1,5 +1,4 @@ -//! Bounded offset pagination. Concurrent posts may shift live results between pages; -//! fixed read views exclude later appends from every page. +//! Bounded offset pagination. Concurrent posts may shift results between pages. //! Cursors belong to the original query; restart without one to refresh the listing. use super::StoredPost; diff --git a/codex-rs/message-board/src/local/queries.rs b/codex-rs/message-board/src/local/queries.rs index 35d9df5263..293560c56e 100644 --- a/codex-rs/message-board/src/local/queries.rs +++ b/codex-rs/message-board/src/local/queries.rs @@ -16,7 +16,6 @@ use super::validate_channel; use crate::AgentMessageBoard; use crate::AppendRequest; use crate::BoardPermissions; -use crate::BoardReadView; use crate::ChannelPage; use crate::ChannelQuery; use crate::ChannelSummary; @@ -30,7 +29,6 @@ use crate::PostQuery; use crate::PostRequest; use crate::ReadPostRequest; use crate::ReadThreadRequest; -use crate::SubscriptionChange; use crate::SubscriptionRequest; use crate::SubscriptionState; use crate::ThreadPage; @@ -45,7 +43,6 @@ use codex_protocol::error::Result; use futures::future::BoxFuture; use sqlx::QueryBuilder; use sqlx::SqliteConnection; -use std::collections::BTreeMap; use std::sync::Arc; use uuid::Uuid; @@ -55,18 +52,13 @@ impl LocalAgentMessageBoard { conn: &mut SqliteConnection, id: Uuid, ) -> Result { - let query = if let Some(view) = self.mode.view() { - sqlx::query_scalar("SELECT payload FROM posts WHERE seq<=? AND board=? AND id=?") - .bind(view.post_cutoff) - } else { + let payload: Option = sqlx::query_scalar("SELECT payload FROM posts WHERE board=? AND id=?") - }; - let payload: Option = query - .bind(self.identity.to_string()) - .bind(id.to_string()) - .fetch_optional(conn) - .await - .map_err(storage_error)?; + .bind(self.identity.to_string()) + .bind(id.to_string()) + .fetch_optional(conn) + .await + .map_err(storage_error)?; serde_json::from_str(&payload.ok_or_else(|| invalid("post not found in this board"))?) .map_err(storage_error) } @@ -103,7 +95,7 @@ impl LocalAgentMessageBoard { caller: ThreadId, request: UpsertChannelRequest, ) -> Result<()> { - if let Some(access) = self.mode.access() { + if let Some(access) = self.access { access.require_write(self.identity, "channel.edit_metadata")?; } let UpsertChannelRequest { @@ -178,13 +170,6 @@ impl AgentMessageBoard for LocalAgentMessageBoard { })) } - fn read_view(&self, caller: ThreadId) -> BoxFuture<'_, Result>> { - Box::pin(async move { - self.host.agent_path(caller).await?; - catalog::capture(self).await - }) - } - fn upsert_channel( &self, caller: ThreadId, @@ -249,14 +234,6 @@ impl AgentMessageBoard for LocalAgentMessageBoard { )) } - fn set_subscriptions<'a>( - &'a self, - caller: ThreadId, - channels: &'a BTreeMap<&str, SubscriptionChange>, - ) -> BoxFuture<'a, Result<()>> { - Box::pin(self.apply_subscriptions(caller, channels)) - } - fn read_post_texts_by_id<'a>( &'a self, caller: ThreadId, @@ -269,12 +246,11 @@ impl AgentMessageBoard for LocalAgentMessageBoard { } let texts = sqlx::query_scalar::<_, String>( "SELECT json_extract(p.payload, '$.text') FROM json_each(?) AS requested - CROSS JOIN posts AS p WHERE p.board=? AND p.id=requested.value AND p.seq<=? + CROSS JOIN posts AS p WHERE p.board=? AND p.id=requested.value ORDER BY requested.key", ) .bind(serde_json::to_string(ids).map_err(storage_error)?) .bind(self.identity.to_string()) - .bind(self.mode.view().map_or(i64::MAX, |view| view.post_cutoff)) .fetch_all(self.pool.as_ref()) .await .map_err(storage_error)?; @@ -300,9 +276,6 @@ impl AgentMessageBoard for LocalAgentMessageBoard { ) -> BoxFuture<'_, Result> { Box::pin(async move { self.host.agent_path(caller).await?; - if let Some(view) = self.mode.view() { - return view.list_channels(query); - } let mut tx = self.pool.begin().await.map_err(storage_error)?; let window = Window::new(&query.page)?; let order = direction(query.direction); @@ -333,7 +306,7 @@ impl AgentMessageBoard for LocalAgentMessageBoard { } Ok(ChannelPage { channels: window.finish(channels)?, - board_permissions: self.mode.access().map(|access| BoardPermissions { + board_permissions: self.access.map(|access| BoardPermissions { create_channel: matches!(access, Access::ReadWrite), edit_metadata: false, manage_permissions: false, @@ -358,50 +331,25 @@ impl AgentMessageBoard for LocalAgentMessageBoard { .fetch_one(&mut *tx) .await .map_err(storage_error)?; - if !exists - || self.mode.view().is_some_and(|view| { - !view - .channels - .iter() - .any(|channel| channel.channel_name == query.channel_name) - }) - { + if !exists { return Err(invalid("channel not found in this board")); } let window = Window::new(&query.page)?; let order = direction(query.direction); // Select the page before looking up reply summaries, especially when // activity sorting examines more roots than the page will return. - let mut sql = QueryBuilder::new("WITH "); - let (roots, by_time, for_count) = if let Some(view) = self.mode.view() { - // A sequence cutoff can make SQLite scan and sort a whole channel or - // thread. Keep the ordered indexes for roots and last activity, and - // allow the reply count to use the sequence range. - sql.push("visible_roots AS NOT MATERIALIZED (SELECT * FROM posts INDEXED BY posts_roots_created WHERE id=root AND seq<=") - .push_bind(view.post_cutoff) - .push("), visible_by_time AS NOT MATERIALIZED (SELECT * FROM posts INDEXED BY posts_board_root_timestamp WHERE seq<=") - .push_bind(view.post_cutoff) - .push("), visible_posts AS NOT MATERIALIZED (SELECT * FROM posts WHERE seq<=") - .push_bind(view.post_cutoff) - .push("), "); - ("visible_roots", "visible_by_time", "visible_posts") - } else { - ("posts", "posts", "posts") - }; - sql.push("page AS MATERIALIZED (SELECT p.board,p.id,p.payload,p.seq,"); + let mut sql = QueryBuilder::new( + "WITH page AS MATERIALIZED (SELECT p.board,p.id,p.payload,p.seq,", + ); match query.sort { ThreadSort::Created => { sql.push("p.timestamp"); } ThreadSort::Activity => { - sql.push("(SELECT MAX(r.timestamp) FROM ") - .push(by_time) - .push(" r WHERE r.board=p.board AND r.root=p.id)"); + sql.push("(SELECT MAX(r.timestamp) FROM posts r WHERE r.board=p.board AND r.root=p.id)"); } } - sql.push(" AS sort_timestamp FROM ") - .push(roots) - .push(" p WHERE p.board=") + sql.push(" AS sort_timestamp FROM posts p WHERE p.board=") .push_bind(self.identity.to_string()) .push(" AND p.channel=") .push_bind(query.channel_name) @@ -415,16 +363,8 @@ impl AgentMessageBoard for LocalAgentMessageBoard { .push_bind(window.offset()) .push( ") SELECT p.payload, - (SELECT COUNT(*) FROM ", - ) - .push(for_count) - .push( - " r WHERE r.board=p.board AND r.root=p.id AND r.id<>r.root), - (SELECT r.payload FROM ", - ) - .push(by_time) - .push( - " r WHERE r.board=p.board AND r.root=p.id AND r.id<>r.root + (SELECT COUNT(*) FROM posts r WHERE r.board=p.board AND r.root=p.id AND r.id<>r.root), + (SELECT r.payload FROM posts r WHERE r.board=p.board AND r.root=p.id AND r.id<>r.root ORDER BY r.timestamp DESC,r.seq DESC LIMIT 1) FROM page p ORDER BY p.sort_timestamp ", ) @@ -471,38 +411,22 @@ impl AgentMessageBoard for LocalAgentMessageBoard { let mut tx = self.pool.begin().await.map_err(storage_error)?; let window = Window::new(&query.page)?; let after = if let Some(id) = query.after_message_id { - let lookup = if let Some(view) = self.mode.view() { - sqlx::query_as::<_, (i64, i64)>( - "SELECT timestamp,seq FROM posts WHERE seq<=? AND board=? AND id=?", - ) - .bind(view.post_cutoff) - } else { - sqlx::query_as("SELECT timestamp,seq FROM posts WHERE board=? AND id=?") - }; Some( - lookup - .bind(self.identity.to_string()) - .bind(id.to_string()) - .fetch_optional(&mut *tx) - .await - .map_err(storage_error)? - .ok_or_else(|| invalid("post not found in this board"))?, + sqlx::query_as::<_, (i64, i64)>( + "SELECT timestamp,seq FROM posts WHERE board=? AND id=?", + ) + .bind(self.identity.to_string()) + .bind(id.to_string()) + .fetch_optional(&mut *tx) + .await + .map_err(storage_error)? + .ok_or_else(|| invalid("post not found in this board"))?, ) } else { None }; - // For a frozen channel page, scan in result order. Otherwise SQLite can - // choose the sequence index for the cutoff and sort the entire channel. - let select = if self.mode.view().is_some() && query.channel_name.is_some() { - "SELECT payload FROM posts INDEXED BY posts_board_channel_timestamp WHERE board=" - } else { - "SELECT payload FROM posts WHERE board=" - }; - let mut sql = QueryBuilder::new(select); + let mut sql = QueryBuilder::new("SELECT payload FROM posts WHERE board="); sql.push_bind(self.identity.to_string()); - if let Some(view) = self.mode.view() { - sql.push(" AND seq<=").push_bind(view.post_cutoff); - } if let Some(channel) = query.channel_name { sql.push(" AND channel=").push_bind(channel); } @@ -558,28 +482,18 @@ impl AgentMessageBoard for LocalAgentMessageBoard { return Err(invalid("thread_id must identify a top-level post")); } let window = Window::new(&request.page)?; - let replies = if let Some(view) = self.mode.view() { - sqlx::query_scalar( - "SELECT payload FROM posts INDEXED BY posts_board_root_timestamp - WHERE seq<=? AND board=? AND root=? AND id<>root - ORDER BY timestamp DESC,seq DESC LIMIT ? OFFSET ?", - ) - .bind(view.post_cutoff) - } else { + let posts = decode_posts( sqlx::query_scalar( "SELECT payload FROM posts WHERE board=? AND root=? AND id<>root ORDER BY timestamp DESC,seq DESC LIMIT ? OFFSET ?", ) - }; - let posts = decode_posts( - replies - .bind(self.identity.to_string()) - .bind(request.thread_id.to_string()) - .bind((window.limit + 1) as i64) - .bind(window.offset()) - .fetch_all(&mut *tx) - .await - .map_err(storage_error)?, + .bind(self.identity.to_string()) + .bind(request.thread_id.to_string()) + .bind((window.limit + 1) as i64) + .bind(window.offset()) + .fetch_all(&mut *tx) + .await + .map_err(storage_error)?, )?; let chars = (request.max_chars_per_post.get() as usize) .min(MAX_READ_CHARS / (posts.len().min(window.limit) + 1)); diff --git a/codex-rs/message-board/src/local/subscriptions.rs b/codex-rs/message-board/src/local/subscriptions.rs index cae59b935c..26bf1e2147 100644 --- a/codex-rs/message-board/src/local/subscriptions.rs +++ b/codex-rs/message-board/src/local/subscriptions.rs @@ -1,61 +1,16 @@ -//! Atomic replacement and discovery of a caller's own channel subscriptions. -//! Thread subscriptions and other agents are unaffected; no notifications are emitted. +//! Update explicit membership and its opt-out together for one subscription target. use super::LocalAgentMessageBoard; -use super::invalid; use super::storage_error; use super::target_key; -use super::validate_channel; use crate::SubscriptionChange; use crate::SubscriptionTarget; use codex_protocol::ThreadId; use codex_protocol::error::Result; use sqlx::Sqlite; use sqlx::Transaction; -use std::collections::BTreeMap; impl LocalAgentMessageBoard { - /// Atomically replaces the caller's membership in the supplied channels. - /// Channels outside this set keep their subscriptions and opt-outs. - /// A read-only live connection permits this self-only operation. - pub(super) async fn apply_subscriptions( - &self, - caller: ThreadId, - channels: &BTreeMap<&str, SubscriptionChange>, - ) -> Result<()> { - self.host.agent_path(caller).await?; - for channel in channels.keys() { - validate_channel(channel)?; - } - let names = - serde_json::to_string(&channels.keys().collect::>()).map_err(storage_error)?; - let mut tx = self.begin_write().await?; - let membership = sqlx::query_as::<_, (String, bool)>( - "SELECT c.name, EXISTS( - SELECT 1 FROM subscriptions AS s WHERE s.board=c.board - AND s.target=json_object('Channel',c.name) AND s.agent=? - ) FROM channels AS c WHERE c.board=? AND c.name IN (SELECT value FROM json_each(?))", - ) - .bind(caller.to_string()) - .bind(self.identity.to_string()) - .bind(names) - .fetch_all(&mut *tx) - .await - .map_err(storage_error)?; - if membership.len() != channels.len() { - return Err(invalid("channel not found in this board")); - } - for (name, subscribed) in membership { - let change = channels[name.as_str()]; - if subscribed == (change == SubscriptionChange::Subscribe) { - continue; - } - self.change_subscription(&mut tx, &SubscriptionTarget::Channel(name), caller, change) - .await?; - } - tx.commit().await.map_err(storage_error) - } - /// Update explicit membership and its matching implicit-subscription opt-out atomically. pub(super) async fn change_subscription( &self, diff --git a/codex-rs/message-board/src/read_view.rs b/codex-rs/message-board/src/read_view.rs deleted file mode 100644 index 052e0f0ce2..0000000000 --- a/codex-rs/message-board/src/read_view.rs +++ /dev/null @@ -1,77 +0,0 @@ -//! Read-only board snapshots with a stable channel catalog and post cutoff. - -use crate::ChannelPage; -use crate::ChannelQuery; -use crate::ChannelSummary; -use crate::Page; -use crate::PostContent; -use crate::PostPreview; -use crate::PostQuery; -use crate::ReadPostRequest; -use crate::ReadThreadRequest; -use crate::ThreadPage; -use crate::ThreadQuery; -use crate::ThreadSummary; -use codex_protocol::SessionId; -use codex_protocol::ThreadId; -use codex_protocol::error::Result; -use futures::future::BoxFuture; -use std::sync::Arc; - -/// A read-only capture of one board. All handles share its namespace, catalog and post cutoff. -/// Later appends and description edits are invisible. Deletion can make captured posts unavailable. -pub trait BoardReadView: Send + Sync { - fn identity(&self) -> SessionId; - fn storage_namespace(&self) -> &str; - fn channels(&self) -> &[ChannelSummary]; - - /// Keep the capture and search literal values in JSON and in the string-encoded JSON at this pointer. - fn with_json_search(&self, pointer: &'static str) -> Arc; - - fn list_channels( - &self, - caller: ThreadId, - query: ChannelQuery, - ) -> BoxFuture<'_, Result>; - - fn list_threads( - &self, - caller: ThreadId, - query: ThreadQuery, - ) -> BoxFuture<'_, Result>>; - - fn search_posts( - &self, - caller: ThreadId, - query: PostQuery, - ) -> BoxFuture<'_, Result>>; - - fn read_thread( - &self, - caller: ThreadId, - request: ReadThreadRequest, - ) -> BoxFuture<'_, Result>; - - fn read_post( - &self, - caller: ThreadId, - request: ReadPostRequest, - ) -> BoxFuture<'_, Result>; - - /// Return one page after the given insertion position, in ascending order. - /// Zero precedes the first post. Positions stay valid across captures of the same board. - /// A page shorter than the default board page size exhausts the captured channel. - fn appended_request_ids<'a>( - &'a self, - caller: ThreadId, - channel: &'a str, - after: i64, - ) -> BoxFuture<'a, Result>>; - - /// Return whole post bodies for one page in the requested order, within this capture. - fn read_post_texts<'a>( - &'a self, - caller: ThreadId, - positions: &'a [i64], - ) -> BoxFuture<'a, Result>>; -} diff --git a/codex-rs/message-board/src/tools.rs b/codex-rs/message-board/src/tools.rs index 102da4ffb6..3498eed905 100644 --- a/codex-rs/message-board/src/tools.rs +++ b/codex-rs/message-board/src/tools.rs @@ -7,7 +7,6 @@ mod spec; use self::selection::MessageBoardTool; use crate::AgentMessageBoard; use crate::AppendRequest; -use crate::BoardReadView; use crate::ChannelQuery; use crate::CreateChannelRequest; use crate::PageRequest; @@ -58,46 +57,6 @@ pub fn message_board_tools( namespace: Option<&str>, namespace_description: &str, tool_messages: Option<&MultiAgentToolMessages>, -) -> Vec ToolExecutor>>> { - bind_tools( - tools, - ToolTarget::Live(board), - caller, - caller_path, - namespace, - namespace_description, - tool_messages, - ) -} - -/// Creates the channel, thread, search and post read tools for one captured view. -pub fn message_board_read_tools( - view: Arc, - caller: ThreadId, - caller_path: AgentPath, - namespace: Option<&str>, - namespace_description: &str, - tool_messages: Option<&MultiAgentToolMessages>, -) -> Vec ToolExecutor>>> { - bind_tools( - &MessageBoardTool::READ_ONLY, - ToolTarget::Fixed(view), - caller, - caller_path, - namespace, - namespace_description, - tool_messages, - ) -} - -fn bind_tools( - tools: &[MessageBoardTool], - target: ToolTarget, - caller: ThreadId, - caller_path: AgentPath, - namespace: Option<&str>, - namespace_description: &str, - tool_messages: Option<&MultiAgentToolMessages>, ) -> Vec ToolExecutor>>> { tools .iter() @@ -114,7 +73,7 @@ fn bind_tools( caller, caller_path: caller_path.clone(), tool, - target: target.clone(), + board: Arc::clone(&board), namespace: namespace.map(str::to_owned), namespace_description: namespace_description.to_owned(), description: tool_message.and_then(|tool| tool.description.clone()), @@ -123,17 +82,11 @@ fn bind_tools( .collect() } -#[derive(Clone)] -enum ToolTarget { - Live(Arc), - Fixed(Arc), -} - struct BoardTool { caller: ThreadId, caller_path: AgentPath, tool: MessageBoardTool, - target: ToolTarget, + board: Arc, namespace: Option, namespace_description: String, description: Option, @@ -211,13 +164,14 @@ impl BoardTool { SortDirection::OldestFirst } }; - match (self.tool, &self.target) { - (MessageBoardTool::UpsertChannel, ToolTarget::Live(board)) => { + let board = &self.board; + match self.tool { + MessageBoardTool::UpsertChannel => { let request = serde_json::from_str(raw).map_err(model_error)?; self.check_mutation_budget(budget, /*target_path_bytes*/ 0)?; encode(board.upsert_channel(caller, request).await) } - (MessageBoardTool::CreateChannel, ToolTarget::Live(board)) => { + MessageBoardTool::CreateChannel => { let arguments::CreateChannel { channel_name, description, @@ -248,7 +202,7 @@ impl BoardTool { .await, ) } - (MessageBoardTool::GetChannels, target) => { + MessageBoardTool::GetChannels => { let arguments::GetChannels { query, recent_first, @@ -262,14 +216,11 @@ impl BoardTool { direction: direction(recent_first), page: page(limit, cursor.clone(), scale), }; - match target { - ToolTarget::Live(board) => board.list_channels(caller, request), - ToolTarget::Fixed(view) => view.list_channels(caller, request), - } + board.list_channels(caller, request) }) .await } - (MessageBoardTool::SubscribedChannels, ToolTarget::Live(board)) => { + MessageBoardTool::SubscribedChannels => { let arguments::SubscribedChannels { limit, cursor } = serde_json::from_str(raw).map_err(model_error)?; let limit = page_limit(limit); @@ -278,7 +229,7 @@ impl BoardTool { }) .await } - (MessageBoardTool::ListThreads, target) => { + MessageBoardTool::ListThreads => { let arguments::ListThreads { channel_name, sort, @@ -297,14 +248,11 @@ impl BoardTool { max_chars_per_post: nonzero(max_chars_per_post / scale), page: page(limit, cursor.clone(), scale), }; - match target { - ToolTarget::Live(board) => board.list_threads(caller, request), - ToolTarget::Fixed(view) => view.list_threads(caller, request), - } + board.list_threads(caller, request) }) .await } - (MessageBoardTool::SearchPosts, target) => { + MessageBoardTool::SearchPosts => { let arguments::SearchPosts { channel_name, query, @@ -329,14 +277,11 @@ impl BoardTool { max_chars_per_post: nonzero(max_chars_per_post / scale), page: page(limit, cursor.clone(), scale), }; - match target { - ToolTarget::Live(board) => board.search_posts(caller, request), - ToolTarget::Fixed(view) => view.search_posts(caller, request), - } + board.search_posts(caller, request) }) .await } - (MessageBoardTool::ReadThread, target) => { + MessageBoardTool::ReadThread => { let arguments::ReadThread { thread_id, limit, @@ -351,14 +296,11 @@ impl BoardTool { max_chars_per_post: nonzero(max_chars_per_post / scale), page: page(limit, cursor.clone(), scale), }; - match target { - ToolTarget::Live(board) => board.read_thread(caller, request), - ToolTarget::Fixed(view) => view.read_thread(caller, request), - } + board.read_thread(caller, request) }) .await } - (MessageBoardTool::ReadPost, target) => { + MessageBoardTool::ReadPost => { let arguments::ReadPost { message_id, offset_chars, @@ -371,17 +313,11 @@ impl BoardTool { offset_chars: offset_chars.unwrap_or_default(), limit_chars: nonzero(limit_chars / scale), }; - match target { - ToolTarget::Live(board) => board.read_post(caller, request), - ToolTarget::Fixed(view) => view.read_post(caller, request), - } + board.read_post(caller, request) }) .await } - ( - MessageBoardTool::Subscribe | MessageBoardTool::Unsubscribe, - ToolTarget::Live(board), - ) => { + MessageBoardTool::Subscribe | MessageBoardTool::Unsubscribe => { let arguments::Subscription { channel_name, thread_id, @@ -417,7 +353,7 @@ impl BoardTool { .await, ) } - (MessageBoardTool::Post | MessageBoardTool::Append, ToolTarget::Live(board)) => { + MessageBoardTool::Post | MessageBoardTool::Append => { let arguments::Post { text, channel_name, @@ -486,10 +422,6 @@ impl BoardTool { .await }) } - (_, ToolTarget::Fixed(_)) => Err(FunctionCallError::Fatal( - "A board mutation was bound to a read-only view".to_string(), - ) - .into()), } } diff --git a/codex-rs/message-board/tests/local_board.rs b/codex-rs/message-board/tests/local_board.rs index 088bd837b2..01536cdc15 100644 --- a/codex-rs/message-board/tests/local_board.rs +++ b/codex-rs/message-board/tests/local_board.rs @@ -1940,89 +1940,6 @@ async fn silent_appends_preserve_evidence_and_explicit_subscriptions() Ok(()) } -#[tokio::test] -async fn bulk_subscriptions_are_atomic_and_scoped_to_the_caller_and_supplied_channels() -> Result<()> -{ - use SubscriptionChange::Subscribe; - use SubscriptionChange::Unsubscribe; - use std::collections::BTreeMap; - - let dir = tempfile::tempdir()?; - let sqlite = SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into().unwrap()); - let owner = ThreadId::new(); - let reviewer = ThreadId::new(); - let host = Arc::new(Host { - clock: AtomicI64::default(), - fail_clock: AtomicBool::default(), - agent_path_calls: AtomicUsize::default(), - members: [ - (owner, AgentPath::root()), - (reviewer, AgentPath::root().join("reviewer").unwrap()), - ] - .into(), - active: AtomicBool::new(true), - fail_notifications: AtomicBool::default(), - notifications: Mutex::default(), - }); - let board = LocalBoard::new(sqlite, owner.into()); - let writer = board.read_write().open(host.clone()).await?; - let reader = board.read_only().open(host.clone()).await?; - for name in ["build", "release"] { - writer - .create_channel( - owner, - CreateChannelRequest { - channel_name: name.into(), - description: None, - subscription: Subscribe, - }, - ) - .await?; - } - reader - .set_subscriptions( - reviewer, - &BTreeMap::from([("build", Subscribe), ("release", Subscribe)]), - ) - .await?; - let both = vec!["build".to_owned(), "release".to_owned()]; - assert!( - reader - .set_subscriptions( - reviewer, - &BTreeMap::from([("build", Unsubscribe), ("missing", Subscribe)]) - ) - .await - .is_err() - ); - assert_eq!( - reader - .subscribed_channels(reviewer, PageRequest::default()) - .await? - .results, - both - ); - reader - .set_subscriptions(reviewer, &BTreeMap::from([("build", Unsubscribe)])) - .await?; - assert_eq!( - reader - .subscribed_channels(reviewer, PageRequest::default()) - .await? - .results, - vec!["release".to_owned()] - ); - assert_eq!( - reader - .subscribed_channels(owner, PageRequest::default()) - .await? - .results, - both - ); - assert!(host.notifications.lock().unwrap().is_empty()); - Ok(()) -} - #[tokio::test] async fn local_board_setup_survives_reopen() -> Result<()> { use serde_json::json; @@ -2270,6 +2187,3 @@ async fn storage_namespaces_preserve_isolation_reopen_and_deletion() -> Result<( #[path = "local_board/mcp_tests.rs"] mod mcp; - -#[path = "local_board/read_view_tests.rs"] -mod read_view; diff --git a/codex-rs/message-board/tests/local_board/read_view_tests.rs b/codex-rs/message-board/tests/local_board/read_view_tests.rs deleted file mode 100644 index 5f5f795dc9..0000000000 --- a/codex-rs/message-board/tests/local_board/read_view_tests.rs +++ /dev/null @@ -1,257 +0,0 @@ -//! Fixed reads share SQLite storage while preserving the captured catalog and post boundary. - -#![cfg(test)] - -use super::*; -use pretty_assertions::assert_eq; - -#[tokio::test] -async fn read_views_freeze_catalog_and_pages_without_changing_live_handles() --> std::result::Result<(), Box> { - let dir = tempfile::tempdir()?; - let sqlite = SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into()?); - let root = ThreadId::new(); - let host = Arc::new(Host { - clock: AtomicI64::default(), - fail_clock: AtomicBool::new(false), - agent_path_calls: AtomicUsize::default(), - members: [(root, AgentPath::root())].into(), - active: AtomicBool::new(true), - fail_notifications: AtomicBool::new(false), - notifications: Mutex::default(), - }); - let writer = LocalAgentMessageBoard::open( - &sqlite, - &LocalBoardOptions::default(), - root.into(), - host.clone(), - ) - .await?; - let reader = LocalBoard::new(sqlite.clone(), root.into()) - .read_only() - .open(host.clone()) - .await?; - for channel in ["alpha", "beta", "empty"] { - writer - .upsert_channel( - root, - UpsertChannelRequest { - channel_name: channel.into(), - description: "Original purpose".to_owned().try_into()?, - }, - ) - .await?; - } - let original = AppendRequest { - request_id: "original".into(), - destination: PostDestination::Channel("alpha".into()), - text: "proof original".into(), - }; - let first = writer.append(root, original).await?; - for (request_id, destination) in [ - ("second", PostDestination::Channel("alpha".into())), - ("reply-one", PostDestination::Thread(first.thread_id)), - ("reply-two", PostDestination::Thread(first.thread_id)), - ("beta", PostDestination::Channel("beta".into())), - ] { - writer - .append( - root, - AppendRequest { - request_id: request_id.into(), - destination, - text: format!("proof {request_id}"), - }, - ) - .await?; - } - let catalog_query = ChannelQuery { - query: None, - direction: SortDirection::NewestFirst, - page: PageRequest::default(), - }; - let before_catalog = reader.list_channels(root, catalog_query.clone()).await?; - let fixed = writer.read_view(root).await?; - assert_eq!(fixed.channels(), before_catalog.channels.results); - assert_eq!( - fixed.list_channels(root, catalog_query.clone()).await?, - before_catalog - ); - let page = PageRequest { - cursor: None, - limit: NonZeroU32::MIN, - }; - let search = PostQuery { - channel_name: Some("alpha".into()), - query: Some("PROOF".into()), - after_message_id: None, - author: Some(AgentPath::root()), - page: page.clone(), - max_chars_per_post: NonZeroU32::MAX, - }; - let before_search = reader.search_posts(root, search.clone()).await?; - let next_search = PostQuery { - page: PageRequest { - cursor: Some(before_search.next_cursor.clone().unwrap()), - ..page.clone() - }, - ..search.clone() - }; - let before_next_search = reader.search_posts(root, next_search.clone()).await?; - let threads = ThreadQuery { - channel_name: "alpha".into(), - sort: ThreadSort::Activity, - direction: SortDirection::OldestFirst, - page: PageRequest::default(), - max_chars_per_post: NonZeroU32::MAX, - }; - let before_threads = reader.list_threads(root, threads.clone()).await?; - let read_thread = ReadThreadRequest { - thread_id: first.thread_id, - page: page.clone(), - max_chars_per_post: NonZeroU32::MAX, - }; - let before_replies = reader.read_thread(root, read_thread.clone()).await?; - let read = ReadPostRequest { - message_id: first.message_id, - offset_chars: 1, - limit_chars: NonZeroU32::MAX, - }; - let content = reader.read_post(root, read.clone()).await?; - - // Both newer and backdated appends must stay outside the fixed sequence boundary. - let mut later = Vec::new(); - for clock in [100, -100] { - host.clock.store(clock, Ordering::SeqCst); - for destination in [ - PostDestination::Channel("alpha".into()), - PostDestination::Thread(first.thread_id), - ] { - later.push( - writer - .append( - root, - AppendRequest { - request_id: format!("later-{clock}-{destination:?}"), - destination, - text: "proof later".into(), - }, - ) - .await?, - ); - } - } - for channel in ["alpha", "new"] { - writer - .upsert_channel( - root, - UpsertChannelRequest { - channel_name: channel.into(), - description: "Updated purpose".to_owned().try_into()?, - }, - ) - .await?; - } - assert_eq!( - fixed.search_posts(root, search.clone()).await?, - before_search - ); - assert_eq!( - fixed.search_posts(root, next_search).await?, - before_next_search - ); - assert_eq!(fixed.list_threads(root, threads).await?, before_threads); - assert_eq!( - fixed.read_thread(root, read_thread.clone()).await?, - before_replies - ); - assert_eq!(fixed.read_post(root, read.clone()).await?, content); - assert_eq!( - fixed.list_channels(root, catalog_query.clone()).await?, - before_catalog - ); - for post in later { - assert!( - fixed - .read_post( - root, - ReadPostRequest { - message_id: post.message_id, - ..read.clone() - } - ) - .await - .is_err() - ); - assert!( - fixed - .search_posts( - root, - PostQuery { - after_message_id: Some(post.message_id), - ..search.clone() - } - ) - .await - .is_err() - ); - if post.message_id == post.thread_id { - assert!( - fixed - .read_thread( - root, - ReadThreadRequest { - thread_id: post.thread_id, - ..read_thread.clone() - } - ) - .await - .is_err() - ); - } - } - assert!( - fixed - .list_threads( - root, - ThreadQuery { - channel_name: "new".into(), - sort: ThreadSort::Created, - direction: SortDirection::NewestFirst, - page: page.clone(), - max_chars_per_post: NonZeroU32::MAX, - } - ) - .await - .is_err() - ); - assert_ne!( - reader.search_posts(root, search.clone()).await?, - fixed.search_posts(root, search).await? - ); - assert_ne!( - reader.list_channels(root, catalog_query.clone()).await?, - before_catalog - ); - assert_eq!( - writer.read_view(root).await?.channels(), - reader - .list_channels(root, catalog_query.clone()) - .await? - .channels - .results - ); - - // A read-only live connection still permits its caller's subscription changes. - let subscription = SubscriptionRequest { - target: SubscriptionTarget::Channel("alpha".into()), - target_agent: None, - change: SubscriptionChange::Subscribe, - }; - reader.set_subscription(root, subscription).await?; - assert_eq!( - reader.subscribed_channels(root, page).await?.results, - vec!["alpha".to_owned()] - ); - Ok(()) -}