manawenuz/featherChat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.0.6: Delivery receipts (sent/delivered/read)

Browse Source 
Protocol:
- WireMessage::Receipt { sender_fingerprint, message_id, receipt_type }
- ReceiptType enum: Delivered, Read
- id field added to KeyExchange and Message variants
- Receipts are plaintext (not encrypted) — contain only ID + type

Web client:
- Auto-sends Delivered receipt on successful decrypt
- Tracks sent message IDs with receipt status
- Displays: ✓ (sent, gray), ✓✓ (delivered, white), ✓✓ (read, blue)
- Receipt indicators update live via DOM reference

CLI TUI:
- Auto-sends Delivered receipt back to sender on decrypt
- Tracks receipt status per message ID
- Displays receipt indicators after sent messages

WASM:
- create_receipt() function for web client
- encrypt_with_id/encrypt_key_exchange_with_id for tracking
- decrypt_wire_message handles Receipt variant

17/17 protocol tests pass. Zero warnings.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Siavash Sameni
2026-03-27 10:12:43 +04:00
parent 8fad8d8374
commit 104ba78b85
8 changed files with 395 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
warzone/Cargo.lock generated
View File

@@ -2647,7 +2647,7 @@ dependencies = [
[[package]]
name = "warzone-client"
version = "0.0.5"
version = "0.0.6"
dependencies = [
"anyhow",
"argon2",
@@ -2679,7 +2679,7 @@ dependencies = [
[[package]]
name = "warzone-mule"
version = "0.0.5"
version = "0.0.6"
dependencies = [
"anyhow",
"clap",
@@ -2688,7 +2688,7 @@ dependencies = [
[[package]]
name = "warzone-protocol"
version = "0.0.5"
version = "0.0.6"
dependencies = [
"base64",
"bincode",
@@ -2711,7 +2711,7 @@ dependencies = [
[[package]]
name = "warzone-server"
version = "0.0.5"
version = "0.0.6"
dependencies = [
"anyhow",
"axum",
@@ -2738,7 +2738,7 @@ dependencies = [
[[package]]
name = "warzone-wasm"
version = "0.0.5"
version = "0.0.6"
dependencies = [
"base64",
"bincode",

2
warzone/Cargo.toml
View File

@@ -9,7 +9,7 @@ members = [
]
[workspace.package]
version = "0.0.5"
version = "0.0.6"
edition = "2021"
license = "MIT"
rust-version = "1.75"

12
warzone/crates/warzone-client/src/cli/recv.rs
View File

@@ -29,6 +29,7 @@ pub async fn run(server_url: &str, identity: &IdentityKeyPair) -> Result<()> {
for raw in &messages {
match bincode::deserialize::<WireMessage>(raw) {
Ok(WireMessage::KeyExchange {
id: _,
sender_fingerprint,
sender_identity_encryption_key,
ephemeral_public,
@@ -80,6 +81,7 @@ pub async fn run(server_url: &str, identity: &IdentityKeyPair) -> Result<()> {
}
}
Ok(WireMessage::Message {
id: _,
sender_fingerprint,
ratchet_message,
}) => {
@@ -105,6 +107,16 @@ pub async fn run(server_url: &str, identity: &IdentityKeyPair) -> Result<()> {
}
}
}
Ok(WireMessage::Receipt {
sender_fingerprint,
message_id,
receipt_type,
}) => {
println!(
" [receipt] {} acknowledged message {} ({:?})",
sender_fingerprint, message_id, receipt_type
);
}
Err(e) => {
eprintln!(" failed to deserialize message: {}", e);
}

2
warzone/crates/warzone-client/src/cli/send.rs
View File

@@ -27,6 +27,7 @@ pub async fn run(recipient_fp: &str, message: &str, server_url: &str, identity:
db.save_session(&recipient, state)?;
WireMessage::Message {
id: uuid::Uuid::new_v4().to_string(),
sender_fingerprint: our_pub.fingerprint.to_string(),
ratchet_message: encrypted,
}
@@ -51,6 +52,7 @@ pub async fn run(recipient_fp: &str, message: &str, server_url: &str, identity:
db.save_session(&recipient, &state)?;
WireMessage::KeyExchange {
id: uuid::Uuid::new_v4().to_string(),
sender_fingerprint: our_pub.fingerprint.to_string(),
sender_identity_encryption_key: *our_pub.encryption.as_bytes(),
ephemeral_public: *x3dh_result.ephemeral_public.as_bytes(),

198
warzone/crates/warzone-client/src/tui/app.rs
View File

@@ -1,3 +1,4 @@
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;
@@ -9,15 +10,23 @@ use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, List, ListItem, Paragraph, Wrap};
use ratatui::Frame;
use warzone_protocol::identity::IdentityKeyPair;
use warzone_protocol::message::{ReceiptType, WireMessage};
use warzone_protocol::ratchet::RatchetState;
use warzone_protocol::types::Fingerprint;
use warzone_protocol::x3dh;
use x25519_dalek::PublicKey;
use warzone_protocol::message::WireMessage;
use crate::net::ServerClient;
use crate::storage::LocalDb;
/// Receipt status for a sent message.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ReceiptStatus {
Sent,
Delivered,
Read,
}
pub struct App {
pub input: String,
pub messages: Arc<Mutex<Vec<ChatLine>>>,
@@ -25,6 +34,8 @@ pub struct App {
pub peer_fp: Option<String>,
pub server_url: String,
pub should_quit: bool,
/// Track receipt status for messages we sent, keyed by message ID.
pub receipts: Arc<Mutex<HashMap<String, ReceiptStatus>>>,
}
#[derive(Clone)]
@@ -33,6 +44,8 @@ pub struct ChatLine {
pub text: String,
pub is_system: bool,
pub is_self: bool,
/// Message ID (for sent messages, used to track receipts).
pub message_id: Option<String>,
}
impl App {
@@ -42,6 +55,7 @@ impl App {
text: format!("You are {}", our_fp),
is_system: true,
is_self: false,
message_id: None,
}]));
if let Some(ref peer) = peer_fp {
@@ -50,6 +64,7 @@ impl App {
text: format!("Chatting with {}", peer),
is_system: true,
is_self: false,
message_id: None,
});
} else {
messages.lock().unwrap().push(ChatLine {
@@ -57,6 +72,7 @@ impl App {
text: "No peer set. Use /peer <fp>, /peer @alias, or /g <group>".into(),
is_system: true,
is_self: false,
message_id: None,
});
}
@@ -65,6 +81,7 @@ impl App {
text: "Commands: /alias <name>, /peer <fp|@alias>, /g <group>, /info, /quit".into(),
is_system: true,
is_self: false,
message_id: None,
});
App {
@@ -74,6 +91,7 @@ impl App {
peer_fp,
server_url,
should_quit: false,
receipts: Arc::new(Mutex::new(HashMap::new())),
}
}
@@ -81,6 +99,34 @@ impl App {
self.messages.lock().unwrap().push(line);
}
fn receipt_indicator(&self, message_id: &Option<String>) -> &'static str {
match message_id {
Some(id) => {
let receipts = self.receipts.lock().unwrap();
match receipts.get(id) {
Some(ReceiptStatus::Read) => " \u{2713}\u{2713}", // ✓✓ (read)
Some(ReceiptStatus::Delivered) => " \u{2713}\u{2713}", // ✓✓ (delivered)
Some(ReceiptStatus::Sent) | None => " \u{2713}", // ✓ (sent)
}
}
None => "",
}
}
fn receipt_color(&self, message_id: &Option<String>) -> Color {
match message_id {
Some(id) => {
let receipts = self.receipts.lock().unwrap();
match receipts.get(id) {
Some(ReceiptStatus::Read) => Color::Blue,
Some(ReceiptStatus::Delivered) => Color::White,
Some(ReceiptStatus::Sent) | None => Color::DarkGray,
}
}
None => Color::DarkGray,
}
}
pub fn draw(&self, frame: &mut Frame) {
let chunks = Layout::default()
.direction(Direction::Vertical)
@@ -127,9 +173,17 @@ impl App {
format!("{}: ", &m.sender[..m.sender.len().min(12)])
};
let receipt_str = if m.is_self && m.message_id.is_some() {
self.receipt_indicator(&m.message_id)
} else {
""
};
let receipt_color = self.receipt_color(&m.message_id);
ListItem::new(Line::from(vec![
Span::styled(prefix, style.add_modifier(Modifier::BOLD)),
Span::raw(&m.text),
Span::styled(receipt_str, Style::default().fg(receipt_color)),
]))
})
.collect();
@@ -178,6 +232,7 @@ impl App {
text: format!("Your fingerprint: {}", self.our_fp),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -205,6 +260,7 @@ impl App {
text: format!("Peer set to {}", fp),
is_system: true,
is_self: false,
message_id: None,
});
self.peer_fp = Some(fp);
return;
@@ -228,6 +284,7 @@ impl App {
text: format!("Switched to group #{}", name),
is_system: true,
is_self: false,
message_id: None,
});
self.peer_fp = Some(format!("#{}", name));
return;
@@ -238,6 +295,7 @@ impl App {
text: "Switched to DM mode. Use /peer <fp>".into(),
is_system: true,
is_self: false,
message_id: None,
});
self.peer_fp = None;
return;
@@ -262,6 +320,7 @@ impl App {
text: "No peer set. Use /peer <fingerprint>".into(),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -275,11 +334,13 @@ impl App {
text: "Invalid peer fingerprint".into(),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
};
let msg_id = uuid::Uuid::new_v4().to_string();
let our_pub = identity.public_identity();
let mut ratchet = db.load_session(&peer_fp).ok().flatten();
@@ -288,6 +349,7 @@ impl App {
Ok(encrypted) => {
let _ = db.save_session(&peer_fp, state);
WireMessage::Message {
id: msg_id.clone(),
sender_fingerprint: our_pub.fingerprint.to_string(),
ratchet_message: encrypted,
}
@@ -298,6 +360,7 @@ impl App {
text: format!("Encrypt failed: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -312,6 +375,7 @@ impl App {
text: format!("Failed to fetch bundle: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -325,6 +389,7 @@ impl App {
text: format!("X3DH failed: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -337,6 +402,7 @@ impl App {
Ok(encrypted) => {
let _ = db.save_session(&peer_fp, &state);
WireMessage::KeyExchange {
id: msg_id.clone(),
sender_fingerprint: our_pub.fingerprint.to_string(),
sender_identity_encryption_key: *our_pub.encryption.as_bytes(),
ephemeral_public: *x3dh_result.ephemeral_public.as_bytes(),
@@ -350,6 +416,7 @@ impl App {
text: format!("Encrypt failed: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -364,6 +431,7 @@ impl App {
text: format!("Serialize failed: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
return;
}
@@ -371,11 +439,14 @@ impl App {
match client.send_message(&peer, Some(&self.our_fp), &encoded).await {
Ok(_) => {
// Track receipt status
self.receipts.lock().unwrap().insert(msg_id.clone(), ReceiptStatus::Sent);
self.add_message(ChatLine {
sender: self.our_fp[..12].to_string(),
text: text.clone(),
is_system: false,
is_self: true,
message_id: Some(msg_id),
});
}
Err(e) => {
@@ -384,6 +455,7 @@ impl App {
text: format!("Send failed: {}", e),
is_system: true,
is_self: false,
message_id: None,
});
}
}
@@ -398,13 +470,13 @@ impl App {
Ok(resp) => {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(err) = data.get("error") {
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false, message_id: None });
} else {
self.add_message(ChatLine { sender: "system".into(), text: format!("Group '{}' created", name), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Group '{}' created", name), is_system: true, is_self: false, message_id: None });
}
}
}
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }),
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }),
}
}
@@ -417,14 +489,14 @@ impl App {
Ok(resp) => {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(err) = data.get("error") {
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false, message_id: None });
} else {
let members = data.get("members").and_then(|v| v.as_u64()).unwrap_or(0);
self.add_message(ChatLine { sender: "system".into(), text: format!("Joined '{}' ({} members)", name, members), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Joined '{}' ({} members)", name, members), is_system: true, is_self: false, message_id: None });
}
}
}
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }),
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }),
}
}
@@ -435,18 +507,18 @@ impl App {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(groups) = data.get("groups").and_then(|v| v.as_array()) {
if groups.is_empty() {
self.add_message(ChatLine { sender: "system".into(), text: "No groups".into(), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: "No groups".into(), is_system: true, is_self: false, message_id: None });
} else {
for g in groups {
let name = g.get("name").and_then(|v| v.as_str()).unwrap_or("?");
let members = g.get("members").and_then(|v| v.as_u64()).unwrap_or(0);
self.add_message(ChatLine { sender: "system".into(), text: format!(" #{} ({} members)", name, members), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!(" #{} ({} members)", name, members), is_system: true, is_self: false, message_id: None });
}
}
}
}
}
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }),
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }),
}
}
@@ -463,9 +535,9 @@ impl App {
let group_data = match client.client.get(&url).send().await {
Ok(resp) => match resp.json::<serde_json::Value>().await {
Ok(d) => d,
Err(e) => { self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }); return; }
Err(e) => { self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }); return; }
},
Err(e) => { self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }); return; }
Err(e) => { self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }); return; }
};
let my_fp = normfp(&self.our_fp);
@@ -491,6 +563,7 @@ impl App {
Ok(encrypted) => {
let _ = db.save_session(&member_fp, state);
WireMessage::Message {
id: uuid::Uuid::new_v4().to_string(),
sender_fingerprint: our_pub.fingerprint.to_string(),
ratchet_message: encrypted,
}
@@ -513,6 +586,7 @@ impl App {
Ok(encrypted) => {
let _ = db.save_session(&member_fp, &state);
WireMessage::KeyExchange {
id: uuid::Uuid::new_v4().to_string(),
sender_fingerprint: our_pub.fingerprint.to_string(),
sender_identity_encryption_key: *our_pub.encryption.as_bytes(),
ephemeral_public: *x3dh_result.ephemeral_public.as_bytes(),
@@ -536,7 +610,7 @@ impl App {
}
if wire_messages.is_empty() {
self.add_message(ChatLine { sender: "system".into(), text: "No members to send to".into(), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: "No members to send to".into(), is_system: true, is_self: false, message_id: None });
return;
}
@@ -554,10 +628,11 @@ impl App {
text: text.to_string(),
is_system: false,
is_self: true,
message_id: None,
});
}
Err(e) => {
self.add_message(ChatLine { sender: "system".into(), text: format!("Send failed: {}", e), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Send failed: {}", e), is_system: true, is_self: false, message_id: None });
}
}
}
@@ -571,14 +646,14 @@ impl App {
Ok(resp) => {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(err) = data.get("error") {
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", err), is_system: true, is_self: false, message_id: None });
} else {
let alias = data.get("alias").and_then(|v| v.as_str()).unwrap_or(name);
self.add_message(ChatLine { sender: "system".into(), text: format!("Alias @{} registered", alias), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Alias @{} registered", alias), is_system: true, is_self: false, message_id: None });
}
}
}
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }),
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }),
}
}
@@ -588,17 +663,17 @@ impl App {
Ok(resp) => {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(fp) = data.get("fingerprint").and_then(|v| v.as_str()) {
self.add_message(ChatLine { sender: "system".into(), text: format!("@{} → {}", name, fp), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("@{} → {}", name, fp), is_system: true, is_self: false, message_id: None });
return Some(fp.to_string());
}
if let Some(err) = data.get("error") {
self.add_message(ChatLine { sender: "system".into(), text: format!("Unknown alias @{}: {}", name, err), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Unknown alias @{}: {}", name, err), is_system: true, is_self: false, message_id: None });
}
}
None
}
Err(e) => {
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None });
None
}
}
@@ -611,18 +686,18 @@ impl App {
if let Ok(data) = resp.json::<serde_json::Value>().await {
if let Some(aliases) = data.get("aliases").and_then(|v| v.as_array()) {
if aliases.is_empty() {
self.add_message(ChatLine { sender: "system".into(), text: "No aliases".into(), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: "No aliases".into(), is_system: true, is_self: false, message_id: None });
} else {
for a in aliases {
let name = a.get("alias").and_then(|v| v.as_str()).unwrap_or("?");
let fp = a.get("fingerprint").and_then(|v| v.as_str()).unwrap_or("?");
self.add_message(ChatLine { sender: "system".into(), text: format!(" @{} → {}...", name, &fp[..fp.len().min(16)]), is_system: true, is_self: false });
self.add_message(ChatLine { sender: "system".into(), text: format!(" @{} → {}...", name, &fp[..fp.len().min(16)]), is_system: true, is_self: false, message_id: None });
}
}
}
}
}
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false }),
Err(e) => self.add_message(ChatLine { sender: "system".into(), text: format!("Error: {}", e), is_system: true, is_self: false, message_id: None }),
}
}
}
@@ -631,15 +706,43 @@ fn normfp(fp: &str) -> String {
fp.chars().filter(|c| c.is_ascii_hexdigit()).collect::<String>().to_lowercase()
}
/// Send a delivery receipt for a message back to its sender.
fn send_receipt(
our_fp: &str,
sender_fp: &str,
message_id: &str,
receipt_type: ReceiptType,
client: &ServerClient,
) {
let receipt = WireMessage::Receipt {
sender_fingerprint: our_fp.to_string(),
message_id: message_id.to_string(),
receipt_type,
};
let encoded = match bincode::serialize(&receipt) {
Ok(e) => e,
Err(_) => return,
};
let client = client.clone();
let to = sender_fp.to_string();
let from = our_fp.to_string();
tokio::spawn(async move {
let _ = client.send_message(&to, Some(&from), &encoded).await;
});
}
/// Process a single incoming raw message (shared by WS and HTTP paths).
fn process_incoming(
raw: &[u8],
identity: &IdentityKeyPair,
db: &LocalDb,
messages: &Arc<Mutex<Vec<ChatLine>>>,
receipts: &Arc<Mutex<HashMap<String, ReceiptStatus>>>,
our_fp: &str,
client: &ServerClient,
) {
match bincode::deserialize::<WireMessage>(raw) {
Ok(wire) => process_wire_message(wire, identity, db, messages),
Ok(wire) => process_wire_message(wire, identity, db, messages, receipts, our_fp, client),
Err(_) => {}
}
}
@@ -649,9 +752,13 @@ fn process_wire_message(
identity: &IdentityKeyPair,
db: &LocalDb,
messages: &Arc<Mutex<Vec<ChatLine>>>,
receipts: &Arc<Mutex<HashMap<String, ReceiptStatus>>>,
our_fp: &str,
client: &ServerClient,
) {
match wire {
WireMessage::KeyExchange {
id,
sender_fingerprint,
sender_identity_encryption_key,
ephemeral_public,
@@ -666,8 +773,8 @@ fn process_wire_message(
Ok(Some(s)) => s,
_ => return,
};
let otpk_secret = if let Some(id) = used_one_time_pre_key_id {
db.take_one_time_pre_key(id).ok().flatten()
let otpk_secret = if let Some(otpk_id) = used_one_time_pre_key_id {
db.take_one_time_pre_key(otpk_id).ok().flatten()
} else {
None
};
@@ -689,12 +796,16 @@ fn process_wire_message(
text,
is_system: false,
is_self: false,
message_id: None,
});
// Send delivery receipt
send_receipt(our_fp, &sender_fingerprint, &id, ReceiptType::Delivered, client);
}
Err(_) => {}
}
}
WireMessage::Message {
id,
sender_fingerprint,
ratchet_message,
} => {
@@ -715,17 +826,43 @@ fn process_wire_message(
text,
is_system: false,
is_self: false,
message_id: None,
});
// Send delivery receipt
send_receipt(our_fp, &sender_fingerprint, &id, ReceiptType::Delivered, client);
}
Err(_) => {}
}
}
WireMessage::Receipt {
sender_fingerprint: _,
message_id,
receipt_type,
} => {
// Update receipt status for the referenced message
let mut r = receipts.lock().unwrap();
let current = r.get(&message_id);
let should_update = match (&receipt_type, current) {
(ReceiptType::Read, _) => true,
(ReceiptType::Delivered, Some(ReceiptStatus::Sent)) => true,
(ReceiptType::Delivered, None) => true,
_ => false,
};
if should_update {
let new_status = match receipt_type {
ReceiptType::Delivered => ReceiptStatus::Delivered,
ReceiptType::Read => ReceiptStatus::Read,
};
r.insert(message_id, new_status);
}
}
}
}
/// Real-time message loop via WebSocket (falls back to HTTP polling).
pub async fn poll_loop(
messages: Arc<Mutex<Vec<ChatLine>>>,
receipts: Arc<Mutex<HashMap<String, ReceiptStatus>>>,
our_fp: String,
identity: IdentityKeyPair,
db: Arc<LocalDb>,
@@ -747,6 +884,7 @@ pub async fn poll_loop(
text: "Real-time connection established".into(),
is_system: true,
is_self: false,
message_id: None,
});
use futures_util::StreamExt;
@@ -754,7 +892,7 @@ pub async fn poll_loop(
while let Some(Ok(msg)) = read.next().await {
if let tokio_tungstenite::tungstenite::Message::Binary(data) = msg {
process_incoming(&data, &identity, &db, &messages);
process_incoming(&data, &identity, &db, &messages, &receipts, &our_fp, &client);
}
}
@@ -763,6 +901,7 @@ pub async fn poll_loop(
text: "Connection lost, reconnecting...".into(),
is_system: true,
is_self: false,
message_id: None,
});
tokio::time::sleep(Duration::from_secs(3)).await;
}
@@ -774,7 +913,7 @@ pub async fn poll_loop(
Err(_) => continue,
};
for raw in &raw_msgs {
process_incoming(raw, &identity, &db, &messages);
process_incoming(raw, &identity, &db, &messages, &receipts, &our_fp, &client);
}
}
}
@@ -799,12 +938,13 @@ pub async fn run_tui(
// Derive a second identity for the poll loop (can't clone IdentityKeyPair)
let poll_identity = poll_seed.derive_identity();
let poll_messages = app.messages.clone();
let poll_receipts = app.receipts.clone();
let poll_client = client.clone();
let poll_db = db.clone();
let poll_fp = our_fp.clone();
tokio::spawn(async move {
poll_loop(poll_messages, poll_fp, poll_identity, poll_db, poll_client).await;
poll_loop(poll_messages, poll_receipts, poll_fp, poll_identity, poll_db, poll_client).await;
});
loop {

15
warzone/crates/warzone-protocol/src/message.rs
View File

@@ -34,12 +34,20 @@ pub enum MessageContent {
Receipt { message_id: MessageId },
}
/// Receipt type: delivered (received + decrypted) or read (user viewed).
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum ReceiptType {
Delivered,
Read,
}
/// Wire message format for transport between clients.
/// Used by both CLI and WASM — MUST be identical for interop.
#[derive(Clone, Serialize, Deserialize)]
pub enum WireMessage {
/// First message to a peer: X3DH key exchange + first ratchet message.
KeyExchange {
id: String,
sender_fingerprint: String,
sender_identity_encryption_key: [u8; 32],
ephemeral_public: [u8; 32],
@@ -48,7 +56,14 @@ pub enum WireMessage {
},
/// Subsequent messages: ratchet-encrypted.
Message {
id: String,
sender_fingerprint: String,
ratchet_message: crate::ratchet::RatchetMessage,
},
/// Delivery / read receipt (plaintext, not encrypted).
Receipt {
sender_fingerprint: String,
message_id: String,
receipt_type: ReceiptType,
},
}

127
warzone/crates/warzone-server/src/routes/web.rs
View File

@@ -143,7 +143,7 @@ const WEB_HTML: &str = r##"<!DOCTYPE html>
</div>
<script type="module">
import init, { WasmIdentity, WasmSession, decrypt_wire_message, self_test, debug_bundle_info } from '/wasm/warzone_wasm.js';
import init, { WasmIdentity, WasmSession, decrypt_wire_message, self_test, debug_bundle_info, create_receipt } from '/wasm/warzone_wasm.js';
const SERVER = window.location.origin;
const $messages = document.getElementById('messages');
@@ -160,9 +160,59 @@ let pollTimer = null;
let ws = null; // WebSocket connection
let wasmReady = false;
const VERSION = '0.0.5';
const VERSION = '0.0.6';
let DEBUG = true; // toggle with /debug command
// ── Receipt tracking ──
let sentMsgReceipts = {}; // messageId -> { status: 'sent'|'delivered'|'read', el: DOM element }
function receiptIndicator(status) {
switch (status) {
case 'read': return '\u2713\u2713';
case 'delivered': return '\u2713\u2713';
case 'sent': default: return '\u2713';
}
}
function receiptColor(status) {
switch (status) {
case 'read': return '#67c7eb';
case 'delivered': return '#ccc';
case 'sent': default: return '#555';
}
}
function updateReceiptDisplay(messageId, status) {
const entry = sentMsgReceipts[messageId];
if (!entry) return;
// Only upgrade status: sent -> delivered -> read
const order = { sent: 0, delivered: 1, read: 2 };
if ((order[status] || 0) <= (order[entry.status] || 0)) return;
entry.status = status;
if (entry.el) {
entry.el.textContent = ' ' + receiptIndicator(status);
entry.el.style.color = receiptColor(status);
}
}
function sendReceipt(toPeerFP, messageId, receiptType) {
try {
const receiptBytes = create_receipt(normFP(myFingerprint), messageId, receiptType);
const fp = normFP(toPeerFP);
if (ws && ws.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify({ to: fp, from: normFP(myFingerprint), message: Array.from(receiptBytes) }));
} else {
fetch(SERVER + '/v1/messages/send', {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ to: fp, from: normFP(myFingerprint), message: Array.from(receiptBytes) })
});
}
dbg('Sent', receiptType, 'receipt for', messageId, 'to', fp);
} catch(e) {
dbg('Failed to send receipt:', e);
}
}
function dbg(...args) {
if (DEBUG) console.log('[WZ]', ...args);
}
@@ -250,6 +300,13 @@ async function fetchPeerBundle(peerFP) {
return bytes;
}
function generateMsgId() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
const r = Math.random() * 16 | 0;
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
}
async function sendEncrypted(peerFP, plaintext) {
const fp = normFP(peerFP);
dbg('sendEncrypted to:', fp, 'text length:', plaintext.length);
@@ -257,23 +314,24 @@ async function sendEncrypted(peerFP, plaintext) {
const bundleBytes = await fetchPeerBundle(fp);
dbg('Got peer bundle, size:', bundleBytes.length);
const msgId = generateMsgId();
let wireBytes;
if (sessions[fp]) {
dbg('Using existing session for', fp);
try {
const sess = WasmSession.restore(sessions[fp].data);
wireBytes = sess.encrypt(wasmIdentity, plaintext);
wireBytes = sess.encrypt_with_id(wasmIdentity, plaintext, msgId);
sessions[fp].data = sess.save();
} catch(e) {
dbg('Existing session encrypt failed, creating new:', e.message);
const sess = WasmSession.initiate(wasmIdentity, bundleBytes);
wireBytes = sess.encrypt_key_exchange(wasmIdentity, bundleBytes, plaintext);
wireBytes = sess.encrypt_key_exchange_with_id(wasmIdentity, bundleBytes, plaintext, msgId);
sessions[fp] = { data: sess.save() };
}
} else {
dbg('New session (X3DH) for', fp);
const sess = WasmSession.initiate(wasmIdentity, bundleBytes);
wireBytes = sess.encrypt_key_exchange(wasmIdentity, bundleBytes, plaintext);
wireBytes = sess.encrypt_key_exchange_with_id(wasmIdentity, bundleBytes, plaintext, msgId);
sessions[fp] = { data: sess.save() };
}
@@ -281,7 +339,7 @@ async function sendEncrypted(peerFP, plaintext) {
Object.fromEntries(Object.entries(sessions).map(([k,v]) => [k, v.data]))
));
dbg('Sending wire message, size:', wireBytes.length);
dbg('Sending wire message, size:', wireBytes.length, 'id:', msgId);
// Prefer WebSocket, fall back to HTTP
if (ws && ws.readyState === WebSocket.OPEN) {
@@ -303,6 +361,8 @@ async function sendEncrypted(peerFP, plaintext) {
});
dbg('Sent via HTTP (WS not connected)');
}
return msgId;
}
function connectWebSocket() {
@@ -339,11 +399,18 @@ function connectWebSocket() {
async function handleIncomingMessage(bytes) {
dbg('Processing message,', bytes.length, 'bytes, sessions:', Object.keys(sessions));
// First try: KeyExchange (no existing session needed)
let decrypted = false;
// Quick check: try to parse as Receipt first (no session needed, no decrypt)
try {
const resultStr = decrypt_wire_message(mySeedHex, mySpkSecretHex, bytes, null);
const result = JSON.parse(resultStr);
if (result.type === 'receipt') {
dbg('Received', result.receipt_type, 'receipt for', result.message_id, 'from', result.sender);
updateReceiptDisplay(result.message_id, result.receipt_type);
return;
}
// It was a KeyExchange
dbg('Decrypted (KeyExchange) from:', result.sender);
const senderFP = normFP(result.sender);
@@ -360,17 +427,25 @@ async function handleIncomingMessage(bytes) {
} catch(e) {}
addMsg(fromLabel, result.text, false);
decrypted = true;
// Send delivery receipt
if (result.message_id) sendReceipt(result.sender, result.message_id, 'delivered');
return;
} catch(e) {
dbg('KeyExchange failed:', e.message || e);
dbg('KeyExchange/Receipt parse failed:', e.message || e);
}
// Second try: existing sessions
if (!decrypted) {
for (const [senderFP, sessData] of Object.entries(sessions)) {
try {
const resultStr = decrypt_wire_message(mySeedHex, mySpkSecretHex, bytes, sessData.data);
const result = JSON.parse(resultStr);
if (result.type === 'receipt') {
dbg('Received', result.receipt_type, 'receipt for', result.message_id);
updateReceiptDisplay(result.message_id, result.receipt_type);
return;
}
dbg('Decrypted with session', senderFP);
sessions[senderFP] = { data: result.session_data };
@@ -386,19 +461,17 @@ async function handleIncomingMessage(bytes) {
} catch(e2) {}
addMsg(fromLabel, result.text, false);
decrypted = true;
break;
// Send delivery receipt
if (result.message_id) sendReceipt(result.sender, result.message_id, 'delivered');
return;
} catch(e2) {
dbg('Session', senderFP, 'failed:', e2.message || e2);
}
}
}
if (!decrypted) {
dbg('ALL decrypt attempts failed');
addSys('[message could not be decrypted]');
}
}
// Load saved sessions
try {
@@ -431,14 +504,25 @@ function peerColor(name) {
return PEER_COLORS[Math.abs(h) % PEER_COLORS.length];
}
function addMsg(from, text, isSelf) {
function addMsg(from, text, isSelf, messageId) {
const d = document.createElement('div');
d.className = 'msg';
const color = isSelf ? '#4ade80' : peerColor(from);
const lock = isSelf ? '' : '<span class="lock">&#128274; </span>';
d.innerHTML = '<span class="ts">' + ts() + '</span> ' + lock + '<span style="color:' + color + ';font-weight:bold">' + esc(from) + '</span>: ' + esc(text);
let receiptHtml = '';
if (isSelf && messageId) {
const status = (sentMsgReceipts[messageId] && sentMsgReceipts[messageId].status) || 'sent';
receiptHtml = ' <span class="receipt" style="color:' + receiptColor(status) + '"> ' + receiptIndicator(status) + '</span>';
}
d.innerHTML = '<span class="ts">' + ts() + '</span> ' + lock + '<span style="color:' + color + ';font-weight:bold">' + esc(from) + '</span>: ' + esc(text) + receiptHtml;
$messages.appendChild(d);
$messages.scrollTop = $messages.scrollHeight;
// Store reference to the receipt span so we can update it later
if (isSelf && messageId) {
const receiptEl = d.querySelector('.receipt');
if (!sentMsgReceipts[messageId]) sentMsgReceipts[messageId] = { status: 'sent', el: null };
sentMsgReceipts[messageId].el = receiptEl;
}
}
function addSys(text) {
@@ -580,7 +664,7 @@ async function sendToGroup(groupName, text) {
body: JSON.stringify({ from: myFP, messages })
});
addMsg(myFingerprint.slice(0, 19) + ' [' + groupName + ']', text, true);
addMsg(myFingerprint.slice(0, 19) + ' [' + groupName + ']', text, true, null);
}
// ── Send handler ──
@@ -677,8 +761,9 @@ async function doSend() {
localStorage.setItem('wz-peer', $peerInput.value.trim());
try {
await sendEncrypted(peer, text);
addMsg(myFingerprint.slice(0, 19), text, true);
const msgId = await sendEncrypted(peer, text);
sentMsgReceipts[msgId] = { status: 'sent', el: null };
addMsg(myFingerprint.slice(0, 19), text, true, msgId);
} catch(e) {
addSys('Send failed: ' + e.message);
}

66
warzone/crates/warzone-wasm/src/lib.rs
View File

@@ -6,7 +6,7 @@
use wasm_bindgen::prelude::*;
use warzone_protocol::identity::{IdentityKeyPair, PublicIdentity, Seed};
use warzone_protocol::message::WireMessage;
use warzone_protocol::message::{ReceiptType, WireMessage};
use warzone_protocol::prekey::{
generate_signed_pre_key, PreKeyBundle,
};
@@ -155,6 +155,16 @@ impl WasmSession {
identity: &WasmIdentity,
their_bundle_bytes: &[u8],
plaintext: &str,
) -> Result<Vec<u8>, JsValue> {
self.encrypt_key_exchange_with_id(identity, their_bundle_bytes, plaintext, &uuid::Uuid::new_v4().to_string())
}
pub fn encrypt_key_exchange_with_id(
&mut self,
identity: &WasmIdentity,
their_bundle_bytes: &[u8],
plaintext: &str,
msg_id: &str,
) -> Result<Vec<u8>, JsValue> {
let bundle: PreKeyBundle = bincode::deserialize(their_bundle_bytes)
.map_err(|e| JsValue::from_str(&e.to_string()))?;
@@ -165,6 +175,7 @@ impl WasmSession {
.map_err(|e| JsValue::from_str(&format!("encrypt: {}", e)))?;
let wire = WireMessage::KeyExchange {
id: msg_id.to_string(),
sender_fingerprint: identity.pub_id.fingerprint.to_string(),
sender_identity_encryption_key: *identity.pub_id.encryption.as_bytes(),
ephemeral_public: *result.ephemeral_public.as_bytes(),
@@ -175,9 +186,14 @@ impl WasmSession {
}
pub fn encrypt(&mut self, identity: &WasmIdentity, plaintext: &str) -> Result<Vec<u8>, JsValue> {
self.encrypt_with_id(identity, plaintext, &uuid::Uuid::new_v4().to_string())
}
pub fn encrypt_with_id(&mut self, identity: &WasmIdentity, plaintext: &str, msg_id: &str) -> Result<Vec<u8>, JsValue> {
let encrypted = self.ratchet.encrypt(plaintext.as_bytes())
.map_err(|e| JsValue::from_str(&format!("encrypt: {}", e)))?;
let wire = WireMessage::Message {
id: msg_id.to_string(),
sender_fingerprint: identity.pub_id.fingerprint.to_string(),
ratchet_message: encrypted,
};
@@ -198,6 +214,30 @@ impl WasmSession {
}
}
// ── Receipt creation ──
/// Create a Receipt wire message (plaintext, not encrypted).
/// `receipt_type`: "delivered" or "read".
/// Returns bincode-serialized bytes.
#[wasm_bindgen]
pub fn create_receipt(
sender_fingerprint: &str,
message_id: &str,
receipt_type: &str,
) -> Result<Vec<u8>, JsValue> {
let rt = match receipt_type {
"delivered" => ReceiptType::Delivered,
"read" => ReceiptType::Read,
_ => return Err(JsValue::from_str("receipt_type must be 'delivered' or 'read'")),
};
let wire = WireMessage::Receipt {
sender_fingerprint: sender_fingerprint.to_string(),
message_id: message_id.to_string(),
receipt_type: rt,
};
bincode::serialize(&wire).map_err(|e| JsValue::from_str(&e.to_string()))
}
// ── Self-test (verifies full encrypt/decrypt cycle within WASM) ──
#[wasm_bindgen]
@@ -241,6 +281,7 @@ pub fn self_test() -> Result<String, JsValue> {
let encrypted_clone = encrypted.clone();
let _wire = WireMessage::KeyExchange {
id: uuid::Uuid::new_v4().to_string(),
sender_fingerprint: alice_pub.fingerprint.to_string(),
sender_identity_encryption_key: *alice_pub.encryption.as_bytes(),
ephemeral_public: *x3dh_result.ephemeral_public.as_bytes(),
@@ -304,7 +345,8 @@ pub fn debug_bundle_info(identity: &mut WasmIdentity) -> Result<String, JsValue>
/// Decrypt a bincode WireMessage. `spk_secret_hex` is the signed pre-key secret
/// (stored in localStorage, generated during identity creation).
/// Returns JSON: { "sender": "fp", "text": "...", "new_session": bool, "session_data": "base64..." }
/// Returns JSON: { "sender": "fp", "text": "...", "new_session": bool, "session_data": "base64...", "message_id": "..." }
/// For Receipt messages: { "type": "receipt", "sender": "fp", "message_id": "...", "receipt_type": "delivered"|"read" }
#[wasm_bindgen]
pub fn decrypt_wire_message(
identity_hex_seed: &str,
@@ -324,6 +366,7 @@ pub fn decrypt_wire_message(
match wire {
WireMessage::KeyExchange {
id: msg_id,
sender_fingerprint,
sender_identity_encryption_key,
ephemeral_public,
@@ -357,9 +400,11 @@ pub fn decrypt_wire_message(
"text": String::from_utf8_lossy(&plain),
"new_session": true,
"session_data": session_b64,
"message_id": msg_id,
}).to_string())
}
WireMessage::Message {
id: msg_id,
sender_fingerprint,
ratchet_message,
} => {
@@ -384,6 +429,23 @@ pub fn decrypt_wire_message(
"text": String::from_utf8_lossy(&plain),
"new_session": false,
"session_data": session_b64,
"message_id": msg_id,
}).to_string())
}
WireMessage::Receipt {
sender_fingerprint,
message_id,
receipt_type,
} => {
let rt_str = match receipt_type {
ReceiptType::Delivered => "delivered",
ReceiptType::Read => "read",
};
Ok(serde_json::json!({
"type": "receipt",
"sender": sender_fingerprint,
"message_id": message_id,
"receipt_type": rt_str,
}).to_string())
}
}