Skip to main content

qualia_client_core/
social_connect.rs

1//! Connect codes, signed invites, and friend contacts for group chat.
2
3use 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    /// Optional tags for ontology / torrent sharing filters (e.g. `health`, `research`).
52    #[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
112/// Generates a connect invite.
113pub 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
206/// Accepts a connect invite.
207pub 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
314/// Loads contacts.
315pub 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
332/// Finds contact-by-did.
333pub fn find_contact_by_did(did: &str) -> Option<ChatContact> {
334    list_chat_contacts().into_iter().find(|c| c.did == did)
335}
336
337/// Updates contact categories.
338pub 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
356/// Lists chat contacts.
357pub 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        // Also test backward compatibility when nym_address is missing in json
413        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}