Struct MessagingService 

pub struct MessagingService { /* private fields */ }

Plugin-internal service handle.

Implementations

impl MessagingService

pub fn open( db_path: PathBuf, peers: Arc<dyn PeerDirectory>, control: Arc<dyn ControlSender>, identity: Arc<dyn IdentitySecrets>, ) -> Result<Self>

Open the messaging database and bind the daemon-supplied ports.

pub fn subscribe(&self) -> Receiver<MessageEvent>

Subscribe to the broadcast event stream. Each subscriber gets every future event until they drop the receiver.

pub fn storage(&self) -> &Arc<MessagingStorage>

Borrow the underlying storage handle (read-mostly use cases like messages.history).

pub async fn list_conversations(&self) -> Result<Vec<ConversationSummary>>

Snapshot of all conversations, sorted by most-recent activity. Each summary’s name and x25519_pubkey are filled in from the peer directory.

pub async fn record_local_send( &self, peer: NodeId, message_id: [u8; 16], body: String, timestamp_ms: i64, ) -> Result<MessageRecord>

Persist a freshly-sent local message in pending status.

pub async fn mark_sent( &self, peer: NodeId, message_id: [u8; 16], at_ms: i64, ) -> Result<()>

Move an outbound message from pending to sent.

pub async fn mark_delivered( &self, peer: NodeId, message_id: [u8; 16], at_ms: i64, ) -> Result<()>

Apply a delivered ack from the peer.

pub async fn mark_read( &self, peer: NodeId, message_id: [u8; 16], at_ms: i64, ) -> Result<()>

Apply a read ack from the peer (if/when supported by the UI).

pub async fn mark_failed( &self, peer: NodeId, message_id: [u8; 16], reason: String, at_ms: i64, ) -> Result<()>

Mark a previously-pending outbound message as failed.

pub async fn delete_conversation(&self, peer: NodeId) -> Result<(usize, bool)>

Atomic per-peer wipe — see MessagingStorage::delete_conversation.

pub async fn delete_all_messages(&self) -> Result<(usize, usize)>

Atomic global wipe — see MessagingStorage::delete_all_messages.

pub async fn send(&self, peer: NodeId, body: String) -> Result<MessageRecord>

Encrypt + send a user message to peer. Returns the persisted record (with status pending initially, transitioning to sent once the transport accepts it). Bumps to failed if no route or no x25519 is known yet.

pub async fn handle_incoming_message(&self, src: NodeId, body: Bytes)

Decrypt + persist an incoming messaging.msg and ack it.

pub async fn handle_incoming_message_ack(&self, src: NodeId, body: Bytes)

Apply an inbound messaging.ack to the local outbound row.

pub async fn on_peer_forgotten(&self, peer: NodeId)

Plugin lifecycle: daemon dropped this peer’s identity. Wipe any per-peer state owned by messaging and emit HistoryCleared so live UIs flush their per-peer buffers.