1use std::fs;
4use std::path::PathBuf;
5
6use serde::{Deserialize, Serialize};
7
8use crate::state::Actor;
9use crate::user_profile::{load_profile, public_profile_card};
10
11const INVITE_TTL_SECS: u64 = 7 * 24 * 3600;
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
14pub struct ConnectInvitePayload {
15 pub version: u8,
16 pub code: String,
17 pub inviter_name: String,
18 pub inviter_did: String,
19 pub inviter_pubkey_hex: String,
20 #[serde(default)]
21 pub relay_endpoint: String,
22 pub front_door_did: String,
23 pub profile_card: serde_json::Value,
24 pub created_at: u64,
25 pub expires_at: u64,
26 pub signature_hex: String,
27 #[serde(default)]
28 pub nym_address: Option<String>,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub struct ConnectInviteSummary {
33 pub code: String,
34 pub invite_json: String,
35 pub mailto_url: String,
36 pub inviter_did: String,
37 pub expires_at: u64,
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
41pub struct ChatContact {
42 pub actor_id: String,
43 pub display_name: String,
44 pub did: String,
45 pub source: String,
46 pub added_at: u64,
47 #[serde(default)]
48 pub relay_endpoint: Option<String>,
49 #[serde(default)]
50 pub nym_address: Option<String>,
51 #[serde(default)]
53 pub categories: Vec<String>,
54}
55
56fn contacts_path() -> PathBuf {
57 crate::state::app_meta_dir().join("chat_contacts.json")
58}
59
60fn unix_now() -> u64 {
61 std::time::SystemTime::now()
62 .duration_since(std::time::UNIX_EPOCH)
63 .unwrap_or_default()
64 .as_secs()
65}
66
67fn format_connect_code(raw: u64) -> String {
68 const ALPHABET: &[u8] = b"ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
69 let mut n = raw;
70 let mut chars = [0u8; 8];
71 for c in &mut chars {
72 *c = ALPHABET[(n % 32) as usize];
73 n /= 32;
74 }
75 format!(
76 "QUALIA-{}-{}",
77 std::str::from_utf8(&chars[0..4]).unwrap_or("XXXX"),
78 std::str::from_utf8(&chars[4..8]).unwrap_or("XXXX")
79 )
80}
81
82fn pct_encode(input: &str) -> String {
83 let mut out = String::new();
84 for b in input.bytes() {
85 match b {
86 b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
87 out.push(b as char);
88 }
89 _ => out.push_str(&format!("%{b:02X}")),
90 }
91 }
92 out
93}
94
95fn resolve_front_door_did(profile: &crate::user_profile::UserProfile) -> String {
96 let state = match crate::state::APP_STATE.get() {
97 Some(s) => s,
98 None => return profile.public_did.clone(),
99 };
100 let doors = state.front_doors.lock().unwrap();
101 if let Some(ref fd_id) = profile.active_front_door_id {
102 if let Some(door) = doors.iter().find(|d| d.id == *fd_id) {
103 return door.did_uri.clone();
104 }
105 }
106 doors
107 .first()
108 .map(|d| d.did_uri.clone())
109 .unwrap_or_else(|| profile.public_did.clone())
110}
111
112pub fn generate_connect_invite(
114 front_door_id: Option<String>,
115) -> Result<ConnectInviteSummary, String> {
116 let profile = load_profile();
117 if !profile.sharing.allow_group_chat_invites {
118 return Err(
119 "Group chat invites are disabled in your profile sharing settings.".to_string(),
120 );
121 }
122
123 let state = crate::state::APP_STATE
124 .get()
125 .ok_or("APP_STATE not initialized")?;
126
127 let mut profile = profile;
128 if let Some(id) = front_door_id {
129 profile.active_front_door_id = Some(id);
130 }
131 profile.public_did = crate::user_profile::resolve_public_did(&profile);
132 let front_door_did = resolve_front_door_did(&profile);
133
134 let created = unix_now();
135 let expires = created + INVITE_TTL_SECS;
136 let code = format_connect_code(created ^ profile.public_did.len() as u64);
137
138 let vault = state.key_vault.lock().unwrap();
139 let signing_key = vault.derive_key("connect-invite");
140 let inviter_pubkey_hex =
141 hex::encode(ed25519_dalek::VerifyingKey::from(&signing_key).as_bytes());
142
143 let relay_endpoint = profile
144 .relay_base_url
145 .clone()
146 .filter(|s| !s.is_empty())
147 .unwrap_or_else(crate::chat_relay::local_relay_base_url);
148
149 let mut payload_unsigned = serde_json::json!({
150 "version": 1,
151 "code": code,
152 "inviter_name": profile.display_name,
153 "inviter_did": profile.public_did,
154 "inviter_pubkey_hex": inviter_pubkey_hex,
155 "relay_endpoint": relay_endpoint,
156 "front_door_did": front_door_did,
157 "profile_card": public_profile_card(&profile),
158 "created_at": created,
159 "expires_at": expires,
160 });
161 if let Some(ref nym) = profile.nym_address {
162 payload_unsigned["nym_address"] = serde_json::json!(nym);
163 }
164
165 let payload_str = serde_json::to_string(&payload_unsigned).map_err(|e| e.to_string())?;
166 let sig = vault.sign_payload(&signing_key, payload_str.as_bytes());
167 let signature_hex = hex::encode(sig.to_bytes());
168 drop(vault);
169
170 let profile_card = public_profile_card(&profile);
171 let invite = ConnectInvitePayload {
172 version: 1,
173 code: code.clone(),
174 inviter_name: profile.display_name.clone(),
175 inviter_did: profile.public_did.clone(),
176 inviter_pubkey_hex,
177 relay_endpoint: relay_endpoint.clone(),
178 front_door_did,
179 profile_card,
180 created_at: created,
181 expires_at: expires,
182 signature_hex,
183 nym_address: profile.nym_address.clone(),
184 };
185
186 let invite_json = serde_json::to_string(&invite).map_err(|e| e.to_string())?;
187 let mailto = if profile.sharing.allow_email_invites {
188 let subject = pct_encode("Join my Qualia chat");
189 let body = pct_encode(&format!(
190 "Connect with me on Qualia.\n\nInvite code: {code}\n\nOr paste this invite JSON in Qualia → Profile → Add Friend:\n{invite_json}"
191 ));
192 format!("mailto:?subject={subject}&body={body}")
193 } else {
194 String::new()
195 };
196
197 Ok(ConnectInviteSummary {
198 code,
199 invite_json,
200 mailto_url: mailto,
201 inviter_did: invite.inviter_did,
202 expires_at: expires,
203 })
204}
205
206pub fn accept_connect_invite(input: &str) -> Result<ChatContact, String> {
208 let invite: ConnectInvitePayload = if input.trim().starts_with('{') {
209 serde_json::from_str(input.trim()).map_err(|e| format!("Invalid invite JSON: {e}"))?
210 } else {
211 return Err(
212 "Paste the full invite JSON from your friend (Profile → Share connect code). Short codes alone are not yet supported for remote lookup.".to_string(),
213 );
214 };
215
216 if unix_now() > invite.expires_at {
217 return Err("This connect invite has expired.".to_string());
218 }
219
220 if !invite.inviter_pubkey_hex.is_empty() && !invite.signature_hex.is_empty() {
221 let pk_bytes = hex::decode(&invite.inviter_pubkey_hex)
222 .map_err(|e| format!("Invalid invite public key: {e}"))?;
223 if pk_bytes.len() == 32 {
224 let sig_bytes = hex::decode(&invite.signature_hex)
225 .map_err(|e| format!("Invalid invite signature: {e}"))?;
226 if sig_bytes.len() == 64 {
227 let mut pk_arr = [0u8; 32];
228 pk_arr.copy_from_slice(&pk_bytes);
229 let mut sig_arr = [0u8; 64];
230 sig_arr.copy_from_slice(&sig_bytes);
231 let mut payload_unsigned = serde_json::json!({
232 "version": invite.version,
233 "code": invite.code,
234 "inviter_name": invite.inviter_name,
235 "inviter_did": invite.inviter_did,
236 "inviter_pubkey_hex": invite.inviter_pubkey_hex,
237 "relay_endpoint": invite.relay_endpoint,
238 "front_door_did": invite.front_door_did,
239 "profile_card": invite.profile_card,
240 "created_at": invite.created_at,
241 "expires_at": invite.expires_at,
242 });
243 if let Some(ref nym) = invite.nym_address {
244 payload_unsigned["nym_address"] = serde_json::json!(nym);
245 }
246 let payload_str =
247 serde_json::to_string(&payload_unsigned).map_err(|e| e.to_string())?;
248 if qualia_core_db::key_vault::KeyVault::verify_signature(
249 &pk_arr,
250 payload_str.as_bytes(),
251 &sig_arr,
252 )
253 .is_err()
254 {
255 return Err("Invite signature verification failed.".to_string());
256 }
257 }
258 }
259 }
260
261 let display_name = invite
262 .profile_card
263 .get("display_name")
264 .and_then(|v| v.as_str())
265 .unwrap_or(&invite.inviter_name)
266 .to_string();
267
268 let short_id = invite
269 .inviter_did
270 .rsplit(':')
271 .next()
272 .unwrap_or("peer")
273 .chars()
274 .take(12)
275 .collect::<String>();
276 let actor = Actor {
277 id: format!("contact-{short_id}"),
278 actor_type: "FRIEND".to_string(),
279 name: display_name.clone(),
280 organization: None,
281 qualifications: vec![],
282 roles: vec!["chat_participant".to_string()],
283 verification_status: "INVITE_ACCEPTED".to_string(),
284 pairwise_did: invite.inviter_did.clone(),
285 root_did_uri: Some(invite.front_door_did.clone()),
286 routing_hints: vec![],
287 };
288
289 crate::api::add_directory_actor(actor)?;
290
291 let contact = ChatContact {
292 actor_id: format!("contact-{short_id}"),
293 display_name,
294 did: invite.inviter_did,
295 source: format!("connect:{}", invite.code),
296 added_at: unix_now(),
297 relay_endpoint: if invite.relay_endpoint.is_empty() {
298 None
299 } else {
300 Some(invite.relay_endpoint)
301 },
302 nym_address: invite.nym_address,
303 categories: vec![],
304 };
305
306 let mut contacts = load_contacts();
307 contacts.retain(|c| c.did != contact.did);
308 contacts.push(contact.clone());
309 save_contacts(&contacts)?;
310
311 Ok(contact)
312}
313
314pub fn load_contacts() -> Vec<ChatContact> {
316 let path = contacts_path();
317 fs::read_to_string(path)
318 .ok()
319 .and_then(|t| serde_json::from_str(&t).ok())
320 .unwrap_or_default()
321}
322
323fn save_contacts(contacts: &[ChatContact]) -> Result<(), String> {
324 let path = contacts_path();
325 if let Some(parent) = path.parent() {
326 fs::create_dir_all(parent).map_err(|e| e.to_string())?;
327 }
328 let text = serde_json::to_string_pretty(contacts).map_err(|e| e.to_string())?;
329 fs::write(path, text).map_err(|e| e.to_string())
330}
331
332pub fn find_contact_by_did(did: &str) -> Option<ChatContact> {
334 list_chat_contacts().into_iter().find(|c| c.did == did)
335}
336
337pub fn update_contact_categories(
339 did: &str,
340 categories: Vec<String>,
341) -> Result<ChatContact, String> {
342 let mut contacts = load_contacts();
343 let idx = contacts
344 .iter()
345 .position(|c| c.did == did)
346 .ok_or_else(|| format!("Contact not found: {did}"))?;
347 contacts[idx].categories = categories
348 .into_iter()
349 .map(|s| s.trim().to_string())
350 .filter(|s| !s.is_empty())
351 .collect();
352 save_contacts(&contacts)?;
353 Ok(contacts[idx].clone())
354}
355
356pub fn list_chat_contacts() -> Vec<ChatContact> {
358 let mut contacts = load_contacts();
359 if contacts.is_empty() {
360 if let Ok(actors) = crate::api::get_directory_actors() {
361 contacts = actors
362 .into_iter()
363 .filter(|a| {
364 a.actor_type == "FRIEND" || a.roles.iter().any(|r| r == "chat_participant")
365 })
366 .map(|a| ChatContact {
367 actor_id: a.id,
368 display_name: a.name,
369 did: a.pairwise_did,
370 source: "directory".to_string(),
371 added_at: unix_now(),
372 relay_endpoint: None,
373 nym_address: None,
374 categories: vec![],
375 })
376 .collect();
377 }
378 }
379 contacts
380}
381
382#[cfg(test)]
383mod tests {
384 use super::*;
385
386 #[test]
387 fn connect_invite_payload_serializes_and_deserializes_nym_address() {
388 let payload = ConnectInvitePayload {
389 version: 1,
390 code: "QUALIA-ABCD-1234".into(),
391 inviter_name: "Alice".into(),
392 inviter_did: "did:qi:alice".into(),
393 inviter_pubkey_hex: "aa".repeat(32),
394 relay_endpoint: "".into(),
395 front_door_did: "did:qi:alice-fd".into(),
396 profile_card: serde_json::json!({ "display_name": "Alice" }),
397 created_at: 1000,
398 expires_at: 2000,
399 signature_hex: "bb".repeat(64),
400 nym_address: Some("alice_client.sphinx@gateway_1".into()),
401 };
402
403 let json_str = serde_json::to_string(&payload).unwrap();
404 assert!(json_str.contains("alice_client.sphinx@gateway_1"));
405
406 let deserialized: ConnectInvitePayload = serde_json::from_str(&json_str).unwrap();
407 assert_eq!(
408 deserialized.nym_address,
409 Some("alice_client.sphinx@gateway_1".into())
410 );
411
412 let legacy_json = serde_json::json!({
414 "version": 1,
415 "code": "QUALIA-LEGACY",
416 "inviter_name": "Bob",
417 "inviter_did": "did:qi:bob",
418 "inviter_pubkey_hex": "aa".repeat(32),
419 "relay_endpoint": "",
420 "front_door_did": "did:qi:bob-fd",
421 "profile_card": {},
422 "created_at": 1000,
423 "expires_at": 2000,
424 "signature_hex": "bb".repeat(64),
425 });
426 let legacy: ConnectInvitePayload = serde_json::from_value(legacy_json).unwrap();
427 assert_eq!(legacy.nym_address, None);
428 }
429}