Skip to main content

qualia_client_core/
chat_relay.rs

1//! Group chat relay — publish to daemon inbox and pull from peer relay endpoints.
2
3use std::collections::HashMap;
4use std::path::{Path, PathBuf};
5use std::sync::atomic::{AtomicBool, Ordering};
6use std::sync::OnceLock;
7use std::time::Duration;
8
9use serde::{Deserialize, Serialize};
10
11use crate::chat_session::{ChatError, Role};
12
13static RELAY_POLLER_STARTED: AtomicBool = AtomicBool::new(false);
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
16pub struct RelayEnvelope {
17    pub session_id: String,
18    pub lamport: u64,
19    pub role: String,
20    pub content: String,
21    pub author_did: String,
22    pub author_name: Option<String>,
23    pub reply_to_fragment: Option<String>,
24    pub timestamp: u64,
25    pub signature_hex: String,
26    #[serde(default, skip_serializing_if = "Option::is_none")]
27    pub sub_agent_of: Option<String>,
28    #[serde(default, skip_serializing_if = "Option::is_none")]
29    pub agent_did: Option<String>,
30    #[serde(default, skip_serializing_if = "Option::is_none")]
31    pub model_id: Option<String>,
32    #[serde(default, skip_serializing_if = "Option::is_none")]
33    pub agent_backend: Option<String>,
34    #[serde(default, skip_serializing_if = "Option::is_none")]
35    pub outcome_sharing: Option<crate::chat_agents::OutcomeSharingPolicy>,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
39struct RelayCursor {
40    per_session: HashMap<String, u64>,
41}
42
43fn cursor_path() -> PathBuf {
44    crate::state::app_meta_dir().join("relay_cursors.json")
45}
46
47fn load_cursors() -> RelayCursor {
48    fs_read_json(cursor_path()).unwrap_or(RelayCursor {
49        per_session: HashMap::new(),
50    })
51}
52
53fn save_cursors(cursors: &RelayCursor) -> Result<(), String> {
54    let path = cursor_path();
55    if let Some(parent) = path.parent() {
56        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
57    }
58    let text = serde_json::to_string_pretty(cursors).map_err(|e| e.to_string())?;
59    std::fs::write(path, text).map_err(|e| e.to_string())
60}
61
62fn fs_read_json<T: for<'de> Deserialize<'de>>(path: PathBuf) -> Option<T> {
63    let text = std::fs::read_to_string(path).ok()?;
64    serde_json::from_str(&text).ok()
65}
66
67/// Local relay-base-url.
68pub fn local_relay_base_url() -> String {
69    let port = crate::api::get_active_daemon_port();
70    if let Some(profile) = profile_relay_base() {
71        if !profile.is_empty() {
72            return profile;
73        }
74    }
75    format!("http://127.0.0.1:{port}")
76}
77
78fn profile_relay_base() -> Option<String> {
79    let profile = crate::user_profile::load_profile();
80    profile.relay_base_url.clone()
81}
82
83fn sign_envelope(envelope: &mut RelayEnvelope) {
84    let payload = serde_json::json!({
85        "session_id": envelope.session_id,
86        "lamport": envelope.lamport,
87        "role": envelope.role,
88        "content": envelope.content,
89        "author_did": envelope.author_did,
90        "author_name": envelope.author_name,
91        "reply_to_fragment": envelope.reply_to_fragment,
92        "timestamp": envelope.timestamp,
93        "sub_agent_of": envelope.sub_agent_of,
94        "agent_did": envelope.agent_did,
95        "model_id": envelope.model_id,
96        "agent_backend": envelope.agent_backend,
97        "outcome_sharing": envelope.outcome_sharing,
98    });
99    let payload_str = serde_json::to_string(&payload).unwrap_or_default();
100    let state = match crate::state::APP_STATE.get() {
101        Some(s) => s,
102        None => return,
103    };
104    let vault = state.key_vault.lock().unwrap();
105    let key = vault.derive_key(&format!("relay:{}", envelope.author_did));
106    let sig = vault.sign_payload(&key, payload_str.as_bytes());
107    envelope.signature_hex = hex::encode(sig.to_bytes());
108}
109
110/// Wraps a message in an envelope.
111pub fn message_to_envelope(
112    session_id: &str,
113    msg: &crate::chat_session::ChatMessage,
114) -> RelayEnvelope {
115    let profile = crate::user_profile::load_profile();
116    let mut envelope = RelayEnvelope {
117        session_id: session_id.to_string(),
118        lamport: msg.lamport,
119        role: msg.role.as_str().to_string(),
120        content: msg.content.clone(),
121        author_did: msg
122            .author_did
123            .clone()
124            .unwrap_or_else(|| profile.public_did.clone()),
125        author_name: msg.author_name.clone(),
126        reply_to_fragment: msg.reply_to_fragment.clone(),
127        timestamp: msg.timestamp,
128        signature_hex: String::new(),
129        sub_agent_of: msg.sub_agent_of.clone(),
130        agent_did: msg.agent_did.clone(),
131        model_id: msg.model_id.clone(),
132        agent_backend: msg.agent_backend.clone(),
133        outcome_sharing: msg.outcome_sharing.clone(),
134    };
135    sign_envelope(&mut envelope);
136    envelope
137}
138
139/// Publishes a session message.
140pub fn publish_session_message(
141    storage_root: &Path,
142    session_id: &str,
143    lamport: u64,
144) -> Result<(), String> {
145    let session =
146        crate::chat_session::load_session(storage_root, session_id).map_err(|e| e.to_string())?;
147    let msg = session
148        .messages
149        .iter()
150        .find(|m| m.lamport == lamport)
151        .ok_or_else(|| format!("message lamport {lamport} not found"))?;
152
153    let envelope = message_to_envelope(session_id, msg);
154    publish_envelope(&session.meta.participants, &envelope)
155}
156
157/// Publishes an envelope to the relay.
158pub fn publish_envelope(
159    participants: &[crate::chat_session::ChatParticipant],
160    envelope: &RelayEnvelope,
161) -> Result<(), String> {
162    let local = local_relay_base_url();
163    let mut endpoints: Vec<String> = vec![local.clone()];
164
165    for p in participants {
166        if let Some(contact) = crate::social_connect::find_contact_by_did(&p.did) {
167            if let Some(url) = contact.relay_endpoint {
168                if !url.is_empty() && !endpoints.contains(&url) {
169                    endpoints.push(url);
170                }
171            }
172        }
173    }
174
175    let client = reqwest::blocking::Client::builder()
176        .timeout(Duration::from_secs(8))
177        .build()
178        .map_err(|e| e.to_string())?;
179
180    let mut last_err = None;
181    for base in endpoints {
182        let url = format!("{}/chat/publish", base.trim_end_matches('/'));
183        match client.post(&url).json(envelope).send() {
184            Ok(resp) if resp.status().is_success() => {}
185            Ok(resp) => {
186                last_err = Some(format!("relay {url} returned {}", resp.status()));
187            }
188            Err(e) => {
189                last_err = Some(format!("relay {url} failed: {e}"));
190            }
191        }
192    }
193
194    if let Some(err) = last_err {
195        eprintln!("[chat_relay] {err}");
196    }
197    Ok(())
198}
199
200#[derive(Debug, Deserialize)]
201pub struct PullResponse {
202    messages: Vec<RelayEnvelope>,
203    latest_lamport: u64,
204}
205
206/// Pulls envelopes from the relay.
207pub fn pull_from_relay(
208    base_url: &str,
209    session_id: &str,
210    since_lamport: u64,
211) -> Result<PullResponse, String> {
212    let url = format!(
213        "{}/chat/pull?session_id={}&since_lamport={}",
214        base_url.trim_end_matches('/'),
215        urlencoding_path(session_id),
216        since_lamport
217    );
218    let client = reqwest::blocking::Client::builder()
219        .timeout(Duration::from_secs(8))
220        .build()
221        .map_err(|e| e.to_string())?;
222    let resp = client.get(&url).send().map_err(|e| e.to_string())?;
223    if !resp.status().is_success() {
224        return Err(format!("pull failed: {}", resp.status()));
225    }
226    resp.json::<PullResponse>().map_err(|e| e.to_string())
227}
228
229fn urlencoding_path(s: &str) -> String {
230    s.chars()
231        .map(|c| match c {
232            'A'..='Z' | 'a'..='z' | '0'..='9' | '-' | '_' | '.' | '~' => c.to_string(),
233            _ => format!("%{:02X}", c as u8),
234        })
235        .collect()
236}
237
238fn ingest_remote_message(
239    storage_root: &Path,
240    session_id: &str,
241    envelope: &RelayEnvelope,
242) -> Result<bool, ChatError> {
243    let profile = crate::user_profile::load_profile();
244    if envelope.author_did == profile.public_did {
245        return Ok(false);
246    }
247
248    let session = crate::chat_session::load_session(storage_root, session_id)?;
249    if session.messages.iter().any(|m| {
250        m.lamport == envelope.lamport
251            && m.author_did.as_deref() == Some(envelope.author_did.as_str())
252    }) {
253        return Ok(false);
254    }
255
256    let role = Role::from_str(&envelope.role)?;
257
258    if role == Role::Agent {
259        let preview = crate::chat_session::ChatMessage {
260            lamport: envelope.lamport,
261            role,
262            content: envelope.content.clone(),
263            timestamp: envelope.timestamp,
264            content_hash: 0,
265            author_did: Some(envelope.author_did.clone()),
266            author_name: envelope.author_name.clone(),
267            reply_to_fragment: envelope.reply_to_fragment.clone(),
268            source: Some(format!("relay:{}", envelope.author_did)),
269            sub_agent_of: envelope.sub_agent_of.clone(),
270            agent_did: envelope.agent_did.clone(),
271            model_id: envelope.model_id.clone(),
272            agent_backend: envelope.agent_backend.clone(),
273            outcome_sharing: envelope.outcome_sharing.clone(),
274        };
275        crate::chat_agents::validate_ingested_agent_message(&preview, &session.meta.participants)
276            .map_err(|e| ChatError::InvalidSession(e))?;
277        if !crate::chat_agents::can_view_agent_outcome(
278            &preview,
279            &profile.public_did,
280            &session.meta.participants,
281        ) {
282            return Ok(false);
283        }
284    }
285
286    let lamport = crate::chat_session::append_relay_message_with_agent_meta(
287        storage_root,
288        session_id,
289        role,
290        &envelope.content,
291        envelope.reply_to_fragment.clone(),
292        Some(format!("relay:{}", envelope.author_did)),
293        Some(envelope.author_did.clone()),
294        envelope.author_name.clone(),
295        envelope.sub_agent_of.clone(),
296        envelope.agent_did.clone(),
297        envelope.model_id.clone(),
298        envelope.agent_backend.clone(),
299        envelope.outcome_sharing.clone(),
300    )?;
301    let _ = lamport;
302    notify_session_updated(session_id);
303
304    Ok(true)
305}
306
307/// Apply an inbound [`RelayEnvelope`] to a session, regardless of the transport it arrived on.
308///
309/// This is the transport-agnostic ingest path shared by the HTTP relay and the SocialWebNet mesh
310/// (`chat_mesh`): it deduplicates by `(lamport, author_did)`, validates agent messages, and appends
311/// the message. Returns `true` if the message was newly applied, `false` if it was a duplicate or
312/// our own echo. Envelope signature verification is the caller's/session policy's concern, exactly as
313/// for the relay pull path.
314pub fn apply_incoming_envelope(
315    storage_root: &Path,
316    session_id: &str,
317    envelope: &RelayEnvelope,
318) -> Result<bool, ChatError> {
319    ingest_remote_message(storage_root, session_id, envelope)
320}
321
322/// Syncs a session with the relay.
323pub fn sync_session_relay(storage_root: &Path, session_id: &str) -> Result<usize, String> {
324    let session =
325        crate::chat_session::load_session(storage_root, session_id).map_err(|e| e.to_string())?;
326
327    let mut cursors = load_cursors();
328    let since = *cursors.per_session.get(session_id).unwrap_or(&0);
329    let mut ingested = 0usize;
330    let mut latest = since;
331
332    let mut endpoints = vec![local_relay_base_url()];
333    for p in &session.meta.participants {
334        if let Some(contact) = crate::social_connect::find_contact_by_did(&p.did) {
335            if let Some(url) = contact.relay_endpoint {
336                if !url.is_empty() && !endpoints.contains(&url) {
337                    endpoints.push(url);
338                }
339            }
340        }
341    }
342
343    for base in endpoints {
344        let pull = match pull_from_relay(&base, session_id, since) {
345            Ok(p) => p,
346            Err(e) => {
347                eprintln!("[chat_relay] pull {base}: {e}");
348                continue;
349            }
350        };
351        latest = latest.max(pull.latest_lamport);
352        for env in pull.messages {
353            if ingest_remote_message(storage_root, session_id, &env).unwrap_or(false) {
354                ingested += 1;
355            }
356        }
357    }
358
359    cursors.per_session.insert(session_id.to_string(), latest);
360    save_cursors(&cursors)?;
361    Ok(ingested)
362}
363
364/// Syncs all group sessions.
365pub fn sync_all_group_sessions() -> Result<usize, String> {
366    let state = crate::state::APP_STATE
367        .get()
368        .ok_or("APP_STATE not initialized")?;
369    let storage = state.config.lock().unwrap().storage_path.clone();
370    let storage_path = Path::new(&storage);
371
372    let sessions = crate::chat_session::list_sessions(storage_path).map_err(|e| e.to_string())?;
373    let mut total = 0usize;
374    for summary in sessions {
375        if summary.session_kind != crate::chat_session::SessionKind::Group {
376            continue;
377        }
378        total += sync_session_relay(storage_path, &summary.id)?;
379    }
380    Ok(total)
381}
382
383/// Starts the relay poller.
384pub fn start_relay_poller() {
385    if RELAY_POLLER_STARTED.swap(true, Ordering::SeqCst) {
386        return;
387    }
388
389    std::thread::spawn(|| loop {
390        if let Err(e) = sync_all_group_sessions() {
391            eprintln!("[chat_relay] poller: {e}");
392        }
393        std::thread::sleep(Duration::from_secs(4));
394    });
395}
396
397static RELAY_NOTIFY: OnceLock<std::sync::Mutex<Option<tokio::sync::broadcast::Sender<String>>>> =
398    OnceLock::new();
399
400/// Relay notify channel.
401pub fn relay_notify_channel() -> tokio::sync::broadcast::Sender<String> {
402    RELAY_NOTIFY
403        .get_or_init(|| {
404            let (tx, _) = tokio::sync::broadcast::channel(64);
405            std::sync::Mutex::new(Some(tx))
406        })
407        .lock()
408        .unwrap()
409        .clone()
410        .expect("relay notify tx")
411}
412
413/// Notifies a session update.
414pub fn notify_session_updated(session_id: &str) {
415    let _ = relay_notify_channel().send(session_id.to_string());
416}