1#![allow(non_snake_case)]
4
5use super::*;
6
7pub 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
27pub 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
32pub 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
56pub 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
61pub 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
67pub 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
83pub 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
133pub 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
189fn 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
199pub 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 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
227pub 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 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 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 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
305pub 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 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 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 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 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 }
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
487pub 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 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
535pub 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
551pub 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
579pub 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
588pub 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
604pub 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
613pub 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 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
648fn 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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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
806pub 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#[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#[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 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}