1use 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
67pub 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
110pub 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
139pub 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
157pub 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
206pub 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
307pub 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
322pub 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
364pub 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
383pub 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
400pub 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
413pub fn notify_session_updated(session_id: &str) {
415 let _ = relay_notify_channel().send(session_id.to_string());
416}