Skip to main content

qualia_client_core/api/
domains.rs

1//! Domains & semantic mail/address stack
2
3#![allow(non_snake_case)]
4
5use super::*;
6
7/// Mail now (unix time).
8pub fn mail_now_unix() -> u64 {
9    std::time::SystemTime::now()
10        .duration_since(std::time::UNIX_EPOCH)
11        .map(|d| d.as_secs())
12        .unwrap_or(0)
13}
14
15fn agent_type_from_token(t: &str) -> crate::domains::AgentType {
16    use crate::domains::AgentType::*;
17    match t {
18        "org" | "organization" => Organization,
19        "ai" | "agent" => AiAgent,
20        "service" | "humanitarian" => HumanitarianService,
21        "content" => ContentProvider,
22        "group" => Group,
23        _ => NaturalPerson,
24    }
25}
26
27/// The person's context-domains (personal/work/projects/…), each an agent with a front-door DID.
28pub fn list_mail_domains() -> Result<serde_json::Value, String> {
29    serde_json::to_value(crate::domains::list_domains()).map_err(|e| e.to_string())
30}
31
32/// Add a context-domain (single-owner). `agent_type` is a token: person/org/ai/service/content/group.
33pub fn add_mail_domain(
34    name: String,
35    agent_type: String,
36    front_door_did: String,
37    label: String,
38    parent: Option<String>,
39) -> Result<serde_json::Value, String> {
40    let owner = crate::domains::DomainOwner::Personal {
41        did: front_door_did.clone(),
42    };
43    let d = crate::domains::make_domain(
44        &name,
45        agent_type_from_token(&agent_type),
46        owner,
47        &front_door_did,
48        &label,
49        parent,
50        mail_now_unix(),
51    )?;
52    crate::domains::upsert_domain(d)?;
53    list_mail_domains()
54}
55
56/// Built-in purpose-inbox presets (frontdoor/junkmail/mygov/newsletters).
57pub fn purpose_inbox_presets() -> Result<serde_json::Value, String> {
58    serde_json::to_value(crate::domains::purpose_presets()).map_err(|e| e.to_string())
59}
60
61/// Addresses (optionally filtered to one domain).
62pub fn list_mail_addresses(domain: Option<String>) -> Result<serde_json::Value, String> {
63    serde_json::to_value(crate::domains::list_addresses(domain.as_deref()))
64        .map_err(|e| e.to_string())
65}
66
67/// Mint a purpose inbox (`frontdoor@`, `junkmail@`, …). `rules_json` is a `MailRules` object (or empty).
68pub fn mint_purpose_inbox(
69    domain: String,
70    local: String,
71    rules_json: String,
72) -> Result<serde_json::Value, String> {
73    let rules: crate::domains::MailRules = if rules_json.trim().is_empty() {
74        crate::domains::MailRules::default()
75    } else {
76        serde_json::from_str(&rules_json).map_err(|e| format!("bad rules json: {e}"))?
77    };
78    let a = crate::domains::make_purpose_address(&domain, &local, rules, mail_now_unix())?;
79    crate::domains::upsert_address(a)?;
80    list_mail_addresses(Some(domain))
81}
82
83/// Onboard mail for a registered domain: mint purpose presets + catchall, then
84/// **auto-start the local SMTP receiver** so the product path finishes without a second hunt.
85pub fn onboard_mail_domain(domain: String) -> Result<serde_json::Value, String> {
86    let minted = crate::domains::onboard_purpose_inboxes(&domain)?;
87    let domain_key = domain.trim().to_lowercase();
88    let addresses = crate::domains::list_addresses(Some(&domain_key));
89    #[cfg(not(target_arch = "wasm32"))]
90    let receiver = match crate::mail_inbound::start_receiver("") {
91        Ok(v) => v,
92        Err(e) => serde_json::json!({
93            "started": false,
94            "error": e,
95            "hint": "Start the receiver from Talk → Mail if bind failed (port in use?).",
96        }),
97    };
98    #[cfg(target_arch = "wasm32")]
99    let receiver = serde_json::json!({ "started": false, "hint": "receiver is native-only" });
100    let mint_msg = if minted.is_empty() {
101        "Mail already onboarded for this domain.".to_string()
102    } else {
103        format!(
104            "Minted {} mailbox(es): {}.",
105            minted.len(),
106            minted.join(", ")
107        )
108    };
109    let recv_msg = if receiver
110        .get("started")
111        .and_then(|x| x.as_bool())
112        .unwrap_or(false)
113        || receiver
114            .get("already_running")
115            .and_then(|x| x.as_bool())
116            .unwrap_or(false)
117    {
118        " Local SMTP receiver running — inbox can accept mail.".to_string()
119    } else if let Some(err) = receiver.get("error").and_then(|e| e.as_str()) {
120        format!(" Receiver not started: {err}.")
121    } else {
122        String::new()
123    };
124    Ok(serde_json::json!({
125        "domain": domain_key,
126        "minted": minted,
127        "addresses": addresses,
128        "receiver": receiver,
129        "message": format!("{mint_msg}{recv_msg}"),
130    }))
131}
132
133/// Human-readable readiness for Talk: domains, mailboxes, receiver, people, so first-run can guide.
134pub fn talk_setup_status() -> Result<serde_json::Value, String> {
135    let domains = crate::domains::list_domains();
136    let addresses = crate::domains::list_addresses(None);
137    let (mail_total, mail_unread, mail_quarantine) = crate::mail_store::counts();
138    let receiver = crate::mail_inbound::receiver_status();
139    let peers = crate::social_peers::list_peers();
140    let contacts_n = crate::social_connect::list_chat_contacts().len();
141    let has_domain = !domains.is_empty();
142    let has_mailboxes = !addresses.is_empty();
143    let receiver_running = receiver
144        .get("running")
145        .and_then(|x| x.as_bool())
146        .unwrap_or(false);
147    let has_people = !peers.is_empty() || contacts_n > 0;
148    let collabs = crate::project_collab::list(None);
149    let dial = crate::social_mesh::dialability(&peers);
150    let dialable = dial.iter().filter(|d| d.dialable_now).count();
151    let reachable = dial.iter().filter(|d| d.reachable).count();
152    let ready_for_mail = has_domain && has_mailboxes && receiver_running;
153    let ready_to_collaborate = has_domain && has_people;
154    Ok(serde_json::json!({
155        "domains": domains.len(),
156        "mailboxes": addresses.len(),
157        "mail_inbox": { "total": mail_total, "unread": mail_unread, "quarantine": mail_quarantine },
158        "receiver": receiver,
159        "peers": peers.len(),
160        "contacts": contacts_n,
161        "collaborators": collabs.len(),
162        "mesh": {
163            "reachable_peers": reachable,
164            "dialable_now": dialable,
165            "reports": dial,
166        },
167        "has_domain": has_domain,
168        "has_mailboxes": has_mailboxes,
169        "receiver_running": receiver_running,
170        "has_people": has_people,
171        "ready_for_mail": ready_for_mail,
172        "ready_to_collaborate": ready_to_collaborate,
173        "next_step": if !has_domain {
174            "reception"
175        } else if !has_mailboxes {
176            "mail_onboard"
177        } else if !receiver_running {
178            "mail_receiver"
179        } else if !has_people {
180            "people"
181        } else if collabs.is_empty() {
182            "projects"
183        } else {
184            "chat_or_projects"
185        },
186    }))
187}
188
189/// Ensure the profile allows connect invites (required for a one-paste join package).
190fn ensure_connect_invites_enabled() -> Result<(), String> {
191    let mut profile = crate::user_profile::load_profile();
192    if !profile.sharing.allow_group_chat_invites {
193        profile.sharing.allow_group_chat_invites = true;
194        crate::user_profile::save_profile(&profile)?;
195    }
196    Ok(())
197}
198
199/// Pure: pull the connect-invite JSON string out of a coop package or bare invite object.
200/// Used by accept + unit tests (no APP_STATE).
201pub fn extract_invite_json_from_package(v: &serde_json::Value) -> Result<String, String> {
202    if v.get("qualia_coop_share").is_some() {
203        let invite_payload = v
204            .get("invite_json")
205            .cloned()
206            .filter(|x| !x.is_null())
207            .ok_or_else(|| {
208                "share package has no invite_json — host must enable invites and rebuild package"
209                    .to_string()
210            })?;
211        if invite_payload.is_string() {
212            let s = invite_payload.as_str().unwrap_or("").trim().to_string();
213            if s.is_empty() {
214                return Err("invite_json string is empty".into());
215            }
216            return Ok(s);
217        }
218        return serde_json::to_string(&invite_payload).map_err(|e| e.to_string());
219    }
220    // Bare ConnectInvitePayload object.
221    if v.get("signature_hex").is_some() && v.get("inviter_did").is_some() {
222        return serde_json::to_string(v).map_err(|e| e.to_string());
223    }
224    Err("not a coop share package or connect invite JSON".into())
225}
226
227/// Build a pasteable **coop share package** — one blob the joiner pastes under People → Accept.
228/// Always embeds a signed connect invite (enables invites if needed). Never includes private keys.
229pub fn coop_share_package(
230    project_id: Option<String>,
231    project_name: Option<String>,
232) -> Result<serde_json::Value, String> {
233    ensure_connect_invites_enabled()?;
234
235    let domains = crate::domains::list_domains();
236    let domain = domains.first().map(|d| d.name.clone()).unwrap_or_default();
237    let front_door = domains
238        .first()
239        .map(|d| d.front_door_did.clone())
240        .unwrap_or_default();
241    let pid = project_id.unwrap_or_default();
242    let pname = project_name.unwrap_or_default();
243    let profile = crate::user_profile::load_profile();
244
245    // Required: invite must succeed for one-paste join (fail closed, not half-package).
246    let invite = crate::social_connect::generate_connect_invite(None).map_err(|e| {
247        format!(
248            "could not embed connect invite: {e}. Set a display name under Talk → People and try again."
249        )
250    })?;
251    let invite_json: serde_json::Value = serde_json::from_str(&invite.invite_json)
252        .unwrap_or_else(|_| serde_json::Value::String(invite.invite_json.clone()));
253
254    #[cfg(not(target_arch = "wasm32"))]
255    let magic = {
256        let fd = if front_door.is_empty() {
257            String::new()
258        } else {
259            front_door.clone()
260        };
261        // Mesh peer material for the joiner (optional second path).
262        generate_magic_link(fd, "collaborator".into(), domain.clone()).ok()
263    };
264    #[cfg(target_arch = "wasm32")]
265    let magic: Option<serde_json::Value> = None;
266
267    // Host also records themselves as steward on the project roster when a project is named.
268    if !pid.is_empty() {
269        let self_did = profile.public_did.clone();
270        if !self_did.is_empty() {
271            let _ = crate::project_collab::add(
272                &pid,
273                &pname,
274                &self_did,
275                &profile.display_name,
276                "steward",
277            );
278        }
279    }
280
281    let package = serde_json::json!({
282        "qualia_coop_share": "1",
283        "from_display_name": profile.display_name,
284        "domain": domain,
285        "front_door_did": front_door,
286        "project_id": pid,
287        "project_name": pname,
288        "members": crate::project_collab::list(if pid.is_empty() { None } else { Some(pid.as_str()) }),
289        "invite_code": invite.code,
290        "invite_json": invite_json,
291        "invite_expires_at": invite.expires_at,
292        "magic_link": magic,
293        "how": [
294            "1. Open Webizen (0.0.25+).",
295            "2. Talk → People → paste this entire JSON under Accept package / invite.",
296            "3. You are connected and the project is scoped on your device.",
297            "4. Talk → People → Start mesh for live peer chat.",
298            "5. Chat with #project:Name_With_Underscores for scoped work.",
299        ],
300        "note": "No private keys. Package is self-contained — one paste joins.",
301    });
302    Ok(package)
303}
304
305/// Accept a **coop share package** or a bare connect-invite JSON (one paste).
306/// Connects to the host, scopes the project, admits host+self on the local roster,
307/// registers mesh peer when magic_link is present, and opens a project group chat when possible.
308pub fn accept_coop_share_package(package_or_invite: String) -> Result<serde_json::Value, String> {
309    let raw = package_or_invite.trim();
310    if raw.is_empty() {
311        return Err("paste a coop share package or invite JSON".into());
312    }
313    let v: serde_json::Value = serde_json::from_str(raw).map_err(|e| format!("not JSON: {e}"))?;
314
315    let invite_str = extract_invite_json_from_package(&v).or_else(|e| {
316        // Bare invite string body already parsed as object without qualia_coop_share.
317        if v.get("inviter_did").is_some() {
318            serde_json::to_string(&v).map_err(|e2| e2.to_string())
319        } else {
320            Err(e)
321        }
322    })?;
323    let contact = crate::social_connect::accept_connect_invite(&invite_str)?;
324
325    let project_id = v
326        .get("project_id")
327        .and_then(|x| x.as_str())
328        .unwrap_or("")
329        .to_string();
330    let project_name = v
331        .get("project_name")
332        .and_then(|x| x.as_str())
333        .unwrap_or("")
334        .to_string();
335
336    let profile = crate::user_profile::load_profile();
337    let mut admitted = Vec::new();
338    if !project_id.is_empty() {
339        let host_did = contact.did.clone();
340        let host_name = if contact.display_name.is_empty() {
341            contact.did.clone()
342        } else {
343            contact.display_name.clone()
344        };
345        if !host_did.is_empty() {
346            if let Ok(row) = crate::project_collab::add(
347                &project_id,
348                &project_name,
349                &host_did,
350                &host_name,
351                "steward",
352            ) {
353                admitted.push(row);
354            }
355        }
356        let self_did = profile.public_did.clone();
357        if self_did.is_empty() {
358            // Ensure we have a resolvable self DID for the roster.
359            let resolved = crate::user_profile::resolve_public_did(&profile);
360            if !resolved.is_empty() {
361                if let Ok(row) = crate::project_collab::add(
362                    &project_id,
363                    &project_name,
364                    &resolved,
365                    &profile.display_name,
366                    "contributor",
367                ) {
368                    admitted.push(row);
369                }
370            }
371        } else if let Ok(row) = crate::project_collab::add(
372            &project_id,
373            &project_name,
374            &self_did,
375            &profile.display_name,
376            "contributor",
377        ) {
378            admitted.push(row);
379        }
380    }
381
382    // Magic link → SocialWebNet peer (mesh), when present.
383    let mut peer_registered = false;
384    #[cfg(not(target_arch = "wasm32"))]
385    if let Some(magic) = v.get("magic_link") {
386        let link = magic
387            .get("deep_link")
388            .or_else(|| magic.get("https_link"))
389            .and_then(|x| x.as_str())
390            .unwrap_or("");
391        if !link.is_empty() {
392            if accept_connection(link.to_string()).is_ok() {
393                peer_registered = true;
394            }
395        }
396    }
397
398    // Project group chat from roster (host + self + any prior members).
399    let mut group_chat: Option<serde_json::Value> = None;
400    if !project_id.is_empty() {
401        match create_project_group_chat(
402            project_id.clone(),
403            if project_name.is_empty() {
404                project_id.clone()
405            } else {
406                project_name.clone()
407            },
408            Some(vec![contact.did.clone()]),
409        ) {
410            Ok(g) => group_chat = Some(g),
411            Err(_) => {
412                // Still ok — roster may be thin; user can create group later.
413            }
414        }
415    }
416
417    Ok(serde_json::json!({
418        "connected": true,
419        "contact": contact,
420        "project_id": project_id,
421        "project_name": project_name,
422        "admitted": admitted,
423        "peer_registered": peer_registered,
424        "group_chat": group_chat,
425        "message": "Joined. Contact saved; project scoped; roster updated; group chat created when possible. Start mesh under People for live peer traffic.",
426    }))
427}
428
429#[cfg(test)]
430mod coop_share_tests {
431    use super::*;
432
433    #[test]
434    fn extract_invite_from_full_package() {
435        let package = serde_json::json!({
436            "qualia_coop_share": "1",
437            "project_id": "board-1",
438            "project_name": "QualiaDB Development Cooperative",
439            "invite_json": {
440                "version": 1,
441                "code": "QUALIA-TEST-TEST",
442                "inviter_name": "Host",
443                "inviter_did": "did:host",
444                "inviter_pubkey_hex": "",
445                "relay_endpoint": "",
446                "front_door_did": "did:host",
447                "profile_card": {},
448                "created_at": 1,
449                "expires_at": 9_999_999_999u64,
450                "signature_hex": ""
451            }
452        });
453        let s = extract_invite_json_from_package(&package).expect("extract");
454        assert!(s.contains("did:host"));
455        assert!(s.contains("QUALIA-TEST-TEST"));
456    }
457
458    #[test]
459    fn extract_invite_from_string_field() {
460        let package = serde_json::json!({
461            "qualia_coop_share": "1",
462            "invite_json": "{\"version\":1,\"code\":\"X\",\"inviter_did\":\"did:x\",\"signature_hex\":\"\"}"
463        });
464        let s = extract_invite_json_from_package(&package).expect("extract string");
465        assert!(s.contains("did:x"));
466    }
467
468    #[test]
469    fn extract_bare_invite_object() {
470        let invite = serde_json::json!({
471            "version": 1,
472            "inviter_did": "did:bare",
473            "signature_hex": "aa",
474            "code": "C"
475        });
476        let s = extract_invite_json_from_package(&invite).expect("bare");
477        assert!(s.contains("did:bare"));
478    }
479
480    #[test]
481    fn extract_rejects_empty_package() {
482        let package = serde_json::json!({ "qualia_coop_share": "1" });
483        assert!(extract_invite_json_from_package(&package).is_err());
484    }
485}
486
487/// Create a group chat for a project from its collaborator roster (+ optional extra DIDs).
488/// Returns `{ session_id, title, participants }`.
489pub fn create_project_group_chat(
490    project_id: String,
491    project_name: String,
492    extra_dids: Option<Vec<String>>,
493) -> Result<serde_json::Value, String> {
494    let mut dids: Vec<String> = crate::project_collab::list(Some(&project_id))
495        .into_iter()
496        .map(|c| c.member_did)
497        .collect();
498    if let Some(extra) = extra_dids {
499        for d in extra {
500            let d = d.trim().to_string();
501            if !d.is_empty() && !dids.iter().any(|x| x == &d) {
502                dids.push(d);
503            }
504        }
505    }
506    // Also fold in all chat contacts if roster empty — last resort so a group can start.
507    if dids.is_empty() {
508        for c in crate::social_connect::list_chat_contacts() {
509            if !c.did.is_empty() {
510                dids.push(c.did);
511            }
512        }
513    }
514    if dids.is_empty() {
515        return Err(
516            "No participants — admit collaborators on the project or accept invites under People first."
517                .into(),
518        );
519    }
520    let title = if project_name.trim().is_empty() {
521        format!("Project {project_id}")
522    } else {
523        format!("Project: {project_name}")
524    };
525    let session_id = create_group_chat_session(Some(title.clone()), dids.clone())?;
526    Ok(serde_json::json!({
527        "session_id": session_id,
528        "title": title,
529        "participants": dids,
530        "project_id": project_id,
531        "message": "Group chat created — open it under Talk → Chat → Conversations.",
532    }))
533}
534
535/// Resolve how mail to `to_address` would be handled (exact / catchall / reject) — pure, for UI/debug.
536pub fn resolve_mail_delivery(to_address: String) -> Result<serde_json::Value, String> {
537    let addresses = crate::domains::list_addresses(None);
538    match crate::domains::resolve_delivery(&addresses, &to_address) {
539        crate::domains::DeliveryResolution::Deliver { address, via } => Ok(serde_json::json!({
540            "deliver": true,
541            "via": via,
542            "address": address,
543        })),
544        crate::domains::DeliveryResolution::Reject { reason } => Ok(serde_json::json!({
545            "deliver": false,
546            "rejected": reason,
547        })),
548    }
549}
550
551/// Persist SMTP/IMAP prefs (app_meta_dir). Passwords stored locally — same trust as desktop secrets.
552pub fn save_mail_transport_config(
553    smtp_json: String,
554    imap_json: String,
555) -> Result<serde_json::Value, String> {
556    let path = crate::state::app_meta_dir().join("mail_transport.json");
557    if let Some(p) = path.parent() {
558        std::fs::create_dir_all(p).map_err(|e| e.to_string())?;
559    }
560    let smtp: Option<crate::mail_transport::SmtpConfig> = if smtp_json.trim().is_empty() {
561        None
562    } else {
563        Some(serde_json::from_str(&smtp_json).map_err(|e| format!("bad smtp: {e}"))?)
564    };
565    let imap: Option<crate::mail_transport::ImapConfig> = if imap_json.trim().is_empty() {
566        None
567    } else {
568        Some(serde_json::from_str(&imap_json).map_err(|e| format!("bad imap: {e}"))?)
569    };
570    let doc = serde_json::json!({ "smtp": smtp, "imap": imap });
571    std::fs::write(
572        &path,
573        serde_json::to_string_pretty(&doc).map_err(|e| e.to_string())?,
574    )
575    .map_err(|e| e.to_string())?;
576    Ok(serde_json::json!({ "saved": true, "path": path.display().to_string() }))
577}
578
579/// Loads mail-transport-config.
580pub fn load_mail_transport_config() -> Result<serde_json::Value, String> {
581    let path = crate::state::app_meta_dir().join("mail_transport.json");
582    match std::fs::read_to_string(path) {
583        Ok(t) => serde_json::from_str(&t).map_err(|e| e.to_string()),
584        Err(_) => Ok(serde_json::json!({ "smtp": null, "imap": null })),
585    }
586}
587
588/// Mint a per-relationship (pairwise) address bound to a relationship DID.
589pub fn mint_relationship_address(
590    domain: String,
591    local: String,
592    relationship_did: String,
593) -> Result<serde_json::Value, String> {
594    let a = crate::domains::make_relationship_address(
595        &domain,
596        &local,
597        &relationship_did,
598        mail_now_unix(),
599    )?;
600    crate::domains::upsert_address(a)?;
601    list_mail_addresses(Some(domain))
602}
603
604/// Enable/disable an address (the surgical per-relationship revoke). Returns the refreshed list.
605pub fn set_mail_address_enabled(
606    address: String,
607    enabled: bool,
608) -> Result<serde_json::Value, String> {
609    crate::domains::set_address_enabled(&address, enabled)?;
610    list_mail_addresses(None)
611}
612
613/// The QDP front-door forms for a domain — the **DNS TXT** (no-hosting anchor), the DNS record name, and
614/// the rich profile in **Turtle + JSON-LD** (served by the local HTTP server over the mesh when hosting).
615pub fn front_door_forms(domain: String) -> Result<serde_json::Value, String> {
616    let d = crate::domains::list_domains()
617        .into_iter()
618        .find(|d| d.name == domain)
619        .ok_or_else(|| format!("unknown domain '{domain}'"))?;
620    // Any eCash address minted as a service could be attached here later; start from the domain identity.
621    let rec = crate::front_door::FrontDoorRecord {
622        domain: d.name.clone(),
623        agent_type: d.agent_type.clone(),
624        front_door_did: d.front_door_did.clone(),
625        name: if d.label.is_empty() {
626            None
627        } else {
628            Some(d.label.clone())
629        },
630        webid: None,
631        services: vec![],
632        identity_pubkey_hex: None,
633        wireguard_pubkey_hex: None,
634        overlay_addr: None,
635        nym_address: None,
636        profile_url: None,
637    };
638    let mail_dns = crate::mail_inbound::mail_dns_forms(&d.name, None);
639    Ok(serde_json::json!({
640        "dns_name": crate::front_door::dns_record_name(&d.name),
641        "dns_txt": rec.to_dns_txt(),
642        "turtle": rec.to_turtle(),
643        "jsonld": rec.to_json_ld(),
644        "mail_dns": mail_dns,
645    }))
646}
647
648/// Build a QDP front-door record from a stored domain's identity (shared by publish/serve).
649fn build_front_door_record(domain: &str) -> Result<crate::front_door::FrontDoorRecord, String> {
650    let d = crate::domains::list_domains()
651        .into_iter()
652        .find(|d| d.name == domain)
653        .ok_or_else(|| format!("unknown domain '{domain}'"))?;
654    Ok(crate::front_door::FrontDoorRecord {
655        domain: d.name.clone(),
656        agent_type: d.agent_type.clone(),
657        front_door_did: d.front_door_did.clone(),
658        name: if d.label.is_empty() {
659            None
660        } else {
661            Some(d.label.clone())
662        },
663        webid: None,
664        services: vec![],
665        identity_pubkey_hex: None,
666        wireguard_pubkey_hex: None,
667        overlay_addr: None,
668        nym_address: None,
669        profile_url: None,
670    })
671}
672
673/// Verify a Cloudflare API token (the easy-install front-door publishing path).
674#[cfg(not(target_arch = "wasm32"))]
675pub fn cf_verify_token(token: String) -> Result<serde_json::Value, String> {
676    crate::cloudflare::verify_token(&token)?;
677    Ok(serde_json::json!({ "ok": true }))
678}
679
680/// List the Cloudflare zones (domains) the token can manage.
681#[cfg(not(target_arch = "wasm32"))]
682pub fn cf_list_zones(token: String) -> Result<serde_json::Value, String> {
683    let zones = crate::cloudflare::list_zones(&token)?;
684    Ok(serde_json::json!(zones
685        .into_iter()
686        .map(|(id, name)| serde_json::json!({ "id": id, "name": name }))
687        .collect::<Vec<_>>()))
688}
689
690/// Publish the domain's `_qdp` TXT front-door record to Cloudflare (no hosting needed).
691#[cfg(not(target_arch = "wasm32"))]
692pub fn cf_publish_front_door(
693    token: String,
694    zone_id: String,
695    domain: String,
696) -> Result<serde_json::Value, String> {
697    let rec = build_front_door_record(&domain)?;
698    let cfg = crate::cloudflare::CfConfig {
699        api_token: token,
700        zone_id,
701    };
702    let id = crate::cloudflare::publish_front_door(&cfg, &rec)?;
703    Ok(serde_json::json!({
704        "record_id": id,
705        "dns_name": crate::front_door::dns_record_name(&domain),
706        "dns_txt": rec.to_dns_txt(),
707    }))
708}
709
710/// Provision a Cloudflare R2 bucket.
711#[cfg(not(target_arch = "wasm32"))]
712pub fn cf_provision_r2_bucket(
713    token: String,
714    account_id: String,
715    bucket_name: String,
716) -> Result<serde_json::Value, String> {
717    crate::cloudflare::provision_r2_bucket(&token, &account_id, &bucket_name)?;
718    Ok(serde_json::json!({ "ok": true, "bucket": bucket_name }))
719}
720
721/// Provision a Cloudflare Worker using the local vendor JS file.
722#[cfg(not(target_arch = "wasm32"))]
723pub fn cf_provision_worker(
724    token: String,
725    account_id: String,
726    script_name: String,
727) -> Result<serde_json::Value, String> {
728    let script_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
729        .join("../../vendor/cloudflare-worker/worker.js");
730    let script_content = std::fs::read_to_string(&script_path)
731        .map_err(|e| format!("Failed to read worker.js: {e}"))?;
732
733    crate::cloudflare::provision_worker(&token, &account_id, &script_name, &script_content)?;
734    Ok(serde_json::json!({ "ok": true, "script": script_name }))
735}
736
737/// Provision a Cloudflare Tunnel.
738#[cfg(not(target_arch = "wasm32"))]
739pub fn cf_provision_tunnel(
740    token: String,
741    account_id: String,
742    tunnel_name: String,
743    tunnel_secret: String,
744) -> Result<serde_json::Value, String> {
745    let tunnel_id =
746        crate::cloudflare::provision_tunnel(&token, &account_id, &tunnel_name, &tunnel_secret)?;
747    Ok(serde_json::json!({ "ok": true, "tunnel_id": tunnel_id }))
748}
749
750/// Route a Cloudflare Tunnel in DNS.
751#[cfg(not(target_arch = "wasm32"))]
752pub fn cf_route_tunnel_dns(
753    token: String,
754    zone_id: String,
755    record_name: String,
756    tunnel_id: String,
757) -> Result<serde_json::Value, String> {
758    let record_id =
759        crate::cloudflare::route_tunnel_dns(&token, &zone_id, &record_name, &tunnel_id)?;
760    Ok(serde_json::json!({ "ok": true, "record_id": record_id }))
761}
762
763/// Verify a GitHub PAT.
764#[cfg(not(target_arch = "wasm32"))]
765pub fn github_verify_token(token: String) -> Result<serde_json::Value, String> {
766    let login = crate::github::verify_github_token(&token).map_err(|e| e.to_string())?;
767    Ok(serde_json::json!({ "ok": true, "login": login }))
768}
769
770/// Create a GitHub repository and push static site files.
771#[cfg(not(target_arch = "wasm32"))]
772pub fn github_deploy_static_site(
773    token: String,
774    repo_name: String,
775    files: std::collections::HashMap<String, String>,
776) -> Result<serde_json::Value, String> {
777    let full_name =
778        crate::github::create_repository(&token, &repo_name).map_err(|e| e.to_string())?;
779    crate::github::push_static_site(&token, &full_name, files).map_err(|e| e.to_string())?;
780    Ok(serde_json::json!({ "ok": true, "full_name": full_name }))
781}
782
783/// Provision a Cloudflare Pages project linked to a GitHub repo.
784#[cfg(not(target_arch = "wasm32"))]
785pub fn cf_provision_pages_project(
786    token: String,
787    account_id: String,
788    project_name: String,
789    github_repo: String,
790) -> Result<serde_json::Value, String> {
791    crate::cloudflare::provision_pages_project(&token, &account_id, &project_name, &github_repo)?;
792    Ok(serde_json::json!({ "ok": true, "project": project_name }))
793}
794
795/// Start serving `/.well-known/QDP` for a domain from a local HTTP server (self-host over the mesh).
796#[cfg(not(target_arch = "wasm32"))]
797pub fn start_qdp_server(domain: String, bind_addr: String) -> Result<serde_json::Value, String> {
798    let rec = build_front_door_record(&domain)?;
799    let addr = bind_addr.clone();
800    std::thread::spawn(move || {
801        let _ = crate::qdp_http::serve_blocking(rec, &addr);
802    });
803    Ok(serde_json::json!({ "serving": bind_addr, "path": crate::qdp_server::WELL_KNOWN_QDP_PATH }))
804}
805
806/// Parse a magic link (deep link / https / bare `qcx1_…`) into the connection identifier it carries.
807pub fn parse_magic_link(link: String) -> Result<serde_json::Value, String> {
808    let id = crate::magic_link::from_link(&link)?;
809    serde_json::to_value(id).map_err(|e| e.to_string())
810}
811
812/// Send mail via SMTP. `smtp_json` = `SmtpConfig`, `mail_json` = `OutgoingMail`.
813#[cfg(not(target_arch = "wasm32"))]
814pub fn mail_send(smtp_json: String, mail_json: String) -> Result<serde_json::Value, String> {
815    let cfg: crate::mail_transport::SmtpConfig =
816        serde_json::from_str(&smtp_json).map_err(|e| format!("bad smtp config: {e}"))?;
817    let mail: crate::mail_transport::OutgoingMail =
818        serde_json::from_str(&mail_json).map_err(|e| format!("bad mail: {e}"))?;
819    crate::mail_transport::send(&cfg, &mail)?;
820    Ok(serde_json::json!({ "sent": true }))
821}
822
823/// Fetch unseen mail via IMAP, apply semantic delivery + rules, and **store accepted mail**
824/// in the local inbox (same store as the SMTP receiver).
825#[cfg(not(target_arch = "wasm32"))]
826pub fn mail_fetch(imap_json: String, mailbox: String) -> Result<serde_json::Value, String> {
827    let cfg: crate::mail_transport::ImapConfig =
828        serde_json::from_str(&imap_json).map_err(|e| format!("bad imap config: {e}"))?;
829    let msgs = crate::mail_transport::fetch_unseen(&cfg, &mailbox)?;
830    let mut stored_ids = Vec::new();
831    let evaluated: Vec<serde_json::Value> = msgs
832        .into_iter()
833        .map(|m| {
834            let to = if m.to_address.contains('@') {
835                m.to_address.clone()
836            } else {
837                cfg.username.clone()
838            };
839            // Reuse the product accept path so IMAP import and SMTP land in one inbox.
840            let r = crate::mail_inbound::accept_message(
841                &m.from_address,
842                &to,
843                &m.subject,
844                &format!("(imported via IMAP; size {} bytes)", m.size_bytes),
845                m.sender_verified,
846                m.sender_did.clone(),
847            );
848            if let Some(ref s) = r.stored {
849                stored_ids.push(s.id.clone());
850            }
851            serde_json::json!({
852                "message": m,
853                "accepted": r.accepted,
854                "rejected": r.rejected,
855                "stored": r.stored,
856            })
857        })
858        .collect();
859    Ok(serde_json::json!({
860        "messages": evaluated,
861        "stored_ids": stored_ids,
862        "stored_count": stored_ids.len(),
863    }))
864}