Initial commit: split VNOX monorepo into VNOX-Client

Desktop client with egui + wgpu UI, audio pipeline (cpal/opus/rodio),
networking (LNEx protocol), and identity management with encrypted vault.

Jitter buffer module extracted from voice-node for standalone operation.
This commit is contained in:
Loki 2026-07-09 11:52:57 +02:00
commit bf0b237afd
112 changed files with 19113 additions and 0 deletions

View file

@ -0,0 +1,167 @@
use std::time::Duration;
use anyhow::Result;
use tokio::net::TcpStream;
use tokio::sync::mpsc;
use tokio::time::{MissedTickBehavior, interval};
use tracing::warn;
use crate::identity::Identity;
use crate::net::{
framing, handshake, internal,
payloads::*,
types::{NetCommand, NetEvent},
};
use serde_json;
use super::super::switch::ReconnectRequested;
use super::{VoiceState, handle_cmd};
pub async fn session_loop(
identity: &Identity,
address: &str,
channels: &mut Vec<String>,
restored: bool,
cmd_rx: &mut mpsc::Receiver<NetCommand>,
event_tx: &mpsc::Sender<NetEvent>,
) -> Result<()> {
let mut stream = TcpStream::connect(address).await?;
let mut seq = 0u32;
let (session_id, node_name, private_mode, crypto) =
handshake::run(&mut stream, identity, &mut seq).await?;
let _ = event_tx
.send(NetEvent::Connected {
session_id: session_id.clone(),
node_name,
restored,
private_mode,
})
.await;
for channel_id in channels.clone() {
framing::io::write_encrypted(
&mut stream,
PID_JOIN_CHANNEL,
&mut seq,
&serde_json::to_vec(&JoinChannelPayload { channel_id })?,
&crypto,
)
.await?;
}
let mut voice_state = VoiceState::new(&crypto, event_tx).await?;
let mut voice_endpoint: Option<std::net::SocketAddr> = None;
let mut ping_tick = interval(Duration::from_secs(2));
ping_tick.set_missed_tick_behavior(MissedTickBehavior::Delay);
loop {
tokio::select! {
_ = ping_tick.tick() => {
let ts = now_ms();
let payload = serde_json::to_vec(&PingPayload { timestamp: ts })?;
framing::io::write_encrypted(&mut stream, PID_PING, &mut seq, &payload, &crypto).await?;
}
result = framing::io::read_encrypted(&mut stream, &crypto) => {
let pkt = result?;
if pkt.packet_id == PID_CHANNEL_STATE
&& let Ok(p) = serde_json::from_slice::<ChannelStatePayload>(&pkt.payload)
{
voice_endpoint = if p.voice_endpoint.is_empty() {
None
} else {
p.voice_endpoint.parse().ok()
};
}
internal::dispatch::incoming(pkt.packet_id, &pkt.payload, event_tx).await?;
}
cmd = cmd_rx.recv() => {
match cmd {
None | Some(NetCommand::Disconnect) => {
let _ = framing::io::write_encrypted(&mut stream, PID_DISCONNECT, &mut seq,
&serde_json::to_vec(&serde_json::json!({"reason":"bye"})).unwrap(), &crypto).await;
return Ok(());
}
Some(NetCommand::Connect { address, auto_reconnect }) => {
warn!("connect while connected to {address}, reconnecting");
if channels.is_empty() {
*channels = vec!["general".into()];
}
return Err(anyhow::Error::new(ReconnectRequested {
address,
auto_reconnect,
}));
}
Some(NetCommand::JoinChannel { channel_id }) => {
track_channel(channels, &channel_id);
framing::io::write_encrypted(&mut stream, PID_JOIN_CHANNEL, &mut seq,
&serde_json::to_vec(&JoinChannelPayload { channel_id })?, &crypto).await?;
}
Some(NetCommand::LeaveChannel { channel_id }) => {
channels.retain(|c| c != &channel_id);
framing::io::write_encrypted(&mut stream, PID_LEAVE_CHANNEL, &mut seq,
&serde_json::to_vec(&LeaveChannelPayload { channel_id })?, &crypto).await?;
}
Some(NetCommand::ChannelCreate { channel_id, channel_name, kind }) => {
let payload = serde_json::to_vec(&ChannelCreatePayload {
channel_id,
channel_name,
kind,
guild_id: None,
})?;
framing::io::write_encrypted(&mut stream, PID_CHANNEL_CREATE, &mut seq, &payload, &crypto).await?;
}
Some(NetCommand::ChannelDelete { channel_id }) => {
let payload = serde_json::to_vec(&ChannelDeletePayload { channel_id })?;
framing::io::write_encrypted(&mut stream, PID_CHANNEL_DELETE, &mut seq, &payload, &crypto).await?;
}
Some(NetCommand::ChannelList) => {
framing::io::write_encrypted(&mut stream, PID_CHANNEL_LIST, &mut seq, b"{}", &crypto).await?;
}
Some(NetCommand::SendChat { channel_id, content, reply_to }) => {
let msg = ChatMessagePayload {
message_id: uuid_v4(), channel_id,
sender_id: identity.pubkey_hex.clone(),
content, timestamp: now_ms(),
edited: false,
reply_to,
};
framing::io::write_encrypted(&mut stream, PID_CHAT_MESSAGE, &mut seq, &serde_json::to_vec(&msg)?, &crypto).await?;
}
Some(NetCommand::SendVoice { channel_id, voice_seq: voice_pkt_seq, timestamp, opus_data }) => {
let sender_pubkey = identity.verifying_key()
.map(|k| k.to_bytes())
.unwrap_or([0u8; 32]);
voice_state.send_voice(channel_id, voice_pkt_seq, timestamp, &opus_data, &crypto, voice_endpoint, &sender_pubkey).await?;
}
Some(NetCommand::ReadReceipt { channel_id, last_read_message_id }) => {
let payload = serde_json::to_vec(&serde_json::json!({
"channel_id": channel_id,
"last_read_message_id": last_read_message_id,
"user_id": identity.pubkey_hex.clone(),
}))?;
framing::io::write_encrypted(&mut stream, PID_READ_RECEIPT, &mut seq, &payload, &crypto).await?;
}
Some(other) => handle_cmd(other, &mut stream, &mut seq, &crypto, identity).await?,
}
}
}
}
}
pub(super) fn now_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as i64
}
pub(super) fn uuid_v4() -> String {
uuid::Uuid::new_v4().to_string()
}
fn track_channel(channels: &mut Vec<String>, channel_id: &str) {
if !channels.iter().any(|c| c == channel_id) {
channels.push(channel_id.to_string());
}
}

View file

@ -0,0 +1,7 @@
mod core;
mod social;
mod voice;
pub use core::session_loop;
pub use social::handle_cmd;
pub use voice::State as VoiceState;

View file

@ -0,0 +1,62 @@
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
seq: &mut u32,
crypto: &SessionCrypto,
) -> Result<()> {
match cmd {
NetCommand::PresenceUpdate {
status,
custom_status,
activity,
activity_text,
} => {
let payload = serde_json::to_vec(&PresenceUpdatePayload {
status,
activity_type: activity,
activity_text,
custom_status,
})?;
framing::io::write_encrypted(stream, PID_PRESENCE_UPDATE, seq, &payload, crypto)
.await?;
}
NetCommand::FriendRequest { target_user_id } => {
let payload = serde_json::to_vec(&FriendRequestPayload { target_user_id })?;
framing::io::write_encrypted(stream, PID_FRIEND_REQUEST, seq, &payload, crypto).await?;
}
NetCommand::FriendAccept { user_id } => {
let payload = serde_json::to_vec(&FriendAcceptPayload { user_id })?;
framing::io::write_encrypted(stream, PID_FRIEND_ACCEPT, seq, &payload, crypto).await?;
}
NetCommand::FriendDecline { user_id } => {
let payload = serde_json::to_vec(&FriendDeclinePayload { user_id })?;
framing::io::write_encrypted(stream, PID_FRIEND_DECLINE, seq, &payload, crypto).await?;
}
NetCommand::FriendRemove { user_id } => {
let payload = serde_json::to_vec(&FriendRemovePayload { user_id })?;
framing::io::write_encrypted(stream, PID_FRIEND_REMOVE, seq, &payload, crypto).await?;
}
NetCommand::FriendList => {
framing::io::write_encrypted(stream, PID_FRIEND_LIST, seq, b"{}", crypto).await?;
}
NetCommand::BlockUser { user_id } => {
let payload = serde_json::to_vec(&BlockUserPayload { user_id })?;
framing::io::write_encrypted(stream, PID_BLOCK_USER, seq, &payload, crypto).await?;
}
NetCommand::UnblockUser { user_id } => {
let payload = serde_json::to_vec(&UnblockUserPayload { user_id })?;
framing::io::write_encrypted(stream, PID_UNBLOCK_USER, seq, &payload, crypto).await?;
}
NetCommand::BlockList => {
framing::io::write_encrypted(stream, PID_BLOCK_LIST, seq, b"{}", crypto).await?;
}
_ => {}
}
Ok(())
}

View file

@ -0,0 +1,143 @@
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
seq: &mut u32,
crypto: &SessionCrypto,
) -> Result<()> {
match cmd {
NetCommand::GuildCreate { name } => {
let payload = serde_json::to_vec(&GuildCreatePayload {
name,
icon_url: None,
})?;
framing::io::write_encrypted(stream, PID_GUILD_CREATE, seq, &payload, crypto).await?;
}
NetCommand::GuildDelete { guild_id } => {
let payload = serde_json::to_vec(&GuildDeletePayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_DELETE, seq, &payload, crypto).await?;
}
NetCommand::GuildList => {
framing::io::write_encrypted(stream, PID_GUILD_LIST, seq, b"{}", crypto).await?;
}
NetCommand::GuildJoin {
guild_id,
invite_code,
} => {
let payload = serde_json::to_vec(&GuildJoinPayload {
guild_id,
invite_code,
})?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_JOIN, seq, &payload, crypto)
.await?;
}
NetCommand::GuildLeave { guild_id } => {
let payload = serde_json::to_vec(&GuildLeavePayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_LEAVE, seq, &payload, crypto)
.await?;
}
NetCommand::InviteCreate {
guild_id,
max_uses,
expires_in_seconds,
} => {
let payload = serde_json::to_vec(&InviteCreatePayload {
guild_id,
max_uses,
expires_in_seconds,
})?;
framing::io::write_encrypted(stream, PID_INVITE_CREATE, seq, &payload, crypto).await?;
}
NetCommand::InviteAccept { code } => {
let payload = serde_json::to_vec(&InviteAcceptPayload { code })?;
framing::io::write_encrypted(stream, PID_INVITE_ACCEPT, seq, &payload, crypto).await?;
}
NetCommand::InviteDelete {
guild_id,
invite_id,
} => {
let payload = serde_json::to_vec(&InviteDeletePayload {
guild_id,
invite_id,
})?;
framing::io::write_encrypted(stream, PID_INVITE_DELETE, seq, &payload, crypto).await?;
}
NetCommand::RoleCreate {
guild_id,
name,
color,
permissions,
} => {
let payload = serde_json::to_vec(&RoleCreatePayload {
guild_id,
name,
color,
permissions,
})?;
framing::io::write_encrypted(stream, PID_ROLE_CREATE, seq, &payload, crypto).await?;
}
NetCommand::RoleDelete { guild_id, role_id } => {
let payload = serde_json::to_vec(&RoleDeletePayload { guild_id, role_id })?;
framing::io::write_encrypted(stream, PID_ROLE_DELETE, seq, &payload, crypto).await?;
}
NetCommand::GuildMemberKick { guild_id, user_id } => {
let payload = serde_json::to_vec(&GuildMemberKickPayload { guild_id, user_id })?;
framing::io::write_encrypted(stream, PID_GUILD_MEMBER_KICK, seq, &payload, crypto)
.await?;
}
NetCommand::GuildAuditLogFetch { guild_id, limit } => {
let payload = serde_json::to_vec(&GuildAuditLogFetchPayload { guild_id, limit })?;
framing::io::write_encrypted(stream, PID_GUILD_AUDIT_LOG_FETCH, seq, &payload, crypto)
.await?;
}
NetCommand::GuildMemberListFetch { guild_id } => {
let payload = serde_json::to_vec(&GuildMemberListFetchPayload { guild_id })?;
framing::io::write_encrypted(
stream,
PID_GUILD_MEMBER_LIST_FETCH,
seq,
&payload,
crypto,
)
.await?;
}
NetCommand::GuildRoleAssign {
guild_id,
user_id,
role_id,
} => {
let payload = serde_json::to_vec(&RoleAssignPayload {
guild_id,
user_id,
role_id,
})?;
framing::io::write_encrypted(stream, PID_GUILD_ROLE_ASSIGN, seq, &payload, crypto)
.await?;
}
NetCommand::GuildRoleUnassign {
guild_id,
user_id,
role_id,
} => {
let payload = serde_json::to_vec(&RoleAssignPayload {
guild_id,
user_id,
role_id,
})?;
framing::io::write_encrypted(stream, PID_GUILD_ROLE_UNASSIGN, seq, &payload, crypto)
.await?;
}
NetCommand::GuildRoleListFetch { guild_id } => {
let payload = serde_json::to_vec(&GuildRoleListFetchPayload { guild_id })?;
framing::io::write_encrypted(stream, PID_GUILD_ROLE_LIST_FETCH, seq, &payload, crypto)
.await?;
}
_ => {}
}
Ok(())
}

View file

@ -0,0 +1,146 @@
mod friends;
mod guild;
use anyhow::Result;
use serde_json;
use tokio::net::TcpStream;
use crate::identity::Identity;
use crate::net::{crypto::SessionCrypto, framing, payloads::*, types::NetCommand};
use super::core::now_ms;
pub async fn handle_cmd(
cmd: NetCommand,
stream: &mut TcpStream,
seq: &mut u32,
crypto: &SessionCrypto,
identity: &Identity,
) -> Result<()> {
match cmd {
cmd @ (NetCommand::GuildCreate { .. }
| NetCommand::GuildDelete { .. }
| NetCommand::GuildList
| NetCommand::GuildJoin { .. }
| NetCommand::GuildLeave { .. }
| NetCommand::InviteCreate { .. }
| NetCommand::InviteAccept { .. }
| NetCommand::InviteDelete { .. }
| NetCommand::RoleCreate { .. }
| NetCommand::RoleDelete { .. }
| NetCommand::GuildMemberKick { .. }
| NetCommand::GuildAuditLogFetch { .. }
| NetCommand::GuildMemberListFetch { .. }
| NetCommand::GuildRoleAssign { .. }
| NetCommand::GuildRoleUnassign { .. }
| NetCommand::GuildRoleListFetch { .. }) => {
guild::handle_cmd(cmd, stream, seq, crypto).await?
}
cmd @ (NetCommand::PresenceUpdate { .. }
| NetCommand::FriendRequest { .. }
| NetCommand::FriendAccept { .. }
| NetCommand::FriendDecline { .. }
| NetCommand::FriendRemove { .. }
| NetCommand::FriendList
| NetCommand::BlockUser { .. }
| NetCommand::UnblockUser { .. }
| NetCommand::BlockList) => friends::handle_cmd(cmd, stream, seq, crypto).await?,
NetCommand::ReactionAdd {
channel_id,
message_id,
emoji,
} => {
let payload = serde_json::to_vec(&ReactionPayload {
message_id,
channel_id,
emoji,
user_id: String::new(),
})?;
framing::io::write_encrypted(stream, PID_MESSAGE_REACTION_ADD, seq, &payload, crypto)
.await?;
}
NetCommand::ReactionRemove {
channel_id,
message_id,
emoji,
} => {
let payload = serde_json::to_vec(&ReactionPayload {
message_id,
channel_id,
emoji,
user_id: String::new(),
})?;
framing::io::write_encrypted(
stream,
PID_MESSAGE_REACTION_REMOVE,
seq,
&payload,
crypto,
)
.await?;
}
NetCommand::MessageEdit {
channel_id,
message_id,
content,
} => {
let payload = serde_json::to_vec(&MessageEditPayload {
message_id,
channel_id,
content,
})?;
framing::io::write_encrypted(stream, PID_MESSAGE_EDIT, seq, &payload, crypto).await?;
}
NetCommand::MessageDelete {
channel_id,
message_id,
} => {
let payload = serde_json::to_vec(&MessageDeletePayload {
message_id,
channel_id,
})?;
framing::io::write_encrypted(stream, PID_MESSAGE_DELETE, seq, &payload, crypto).await?;
}
NetCommand::DmStart { target_user_id } => {
let payload = serde_json::to_vec(&DmStartPayload { target_user_id })?;
framing::io::write_encrypted(stream, PID_DM_START, seq, &payload, crypto).await?;
}
NetCommand::DmSend { dm_id, content } => {
let msg = DmMessagePayload {
dm_id,
sender_id: identity.pubkey_hex.clone(),
content,
timestamp: now_ms(),
};
framing::io::write_encrypted(
stream,
PID_DM_MESSAGE,
seq,
&serde_json::to_vec(&msg)?,
crypto,
)
.await?;
}
NetCommand::TypingStart { channel_id } => {
let payload = serde_json::to_vec(&serde_json::json!({"channel_id": channel_id}))?;
framing::io::write_encrypted(stream, PID_TYPING_START, seq, &payload, crypto).await?;
}
NetCommand::DmReadAck { dm_id } => {
let payload = serde_json::to_vec(&serde_json::json!({"dm_id": dm_id}))?;
framing::io::write_encrypted(stream, PID_DM_READ_ACK, seq, &payload, crypto).await?;
}
NetCommand::DmSearch { dm_id, query } => {
let payload = serde_json::to_vec(&DmHistoryPayload {
dm_id,
messages: vec![],
search_query: if query.is_empty() { None } else { Some(query) },
limit: None,
})?;
framing::io::write_encrypted(stream, PID_DM_HISTORY, seq, &payload, crypto).await?;
}
_ => {}
}
Ok(())
}

View file

@ -0,0 +1,47 @@
use std::sync::Arc;
use anyhow::Result;
use tokio::net::UdpSocket;
use tokio::sync::mpsc;
use crate::net::{crypto::SessionCrypto, types::NetEvent};
pub struct State {
pub udp: Arc<UdpSocket>,
pub seq: u64,
}
impl State {
pub async fn new(crypto: &SessionCrypto, event_tx: &mpsc::Sender<NetEvent>) -> Result<Self> {
let udp = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
crate::net::voice::spawn_recv(udp.clone(), (*crypto).clone(), event_tx.clone());
Ok(Self { udp, seq: 0 })
}
#[allow(clippy::too_many_arguments)]
pub async fn send_voice(
&mut self,
channel_id: u64,
voice_pkt_seq: u32,
timestamp: u32,
opus_data: &[u8],
crypto: &SessionCrypto,
endpoint: Option<std::net::SocketAddr>,
sender_pubkey: &[u8; 32],
) -> Result<()> {
if let Some(ep) = endpoint {
let pkt = crate::net::voice::build_packet(
channel_id,
voice_pkt_seq,
timestamp,
opus_data,
crypto,
self.seq,
sender_pubkey,
);
let _ = self.udp.send_to(&pkt, ep).await;
self.seq += 1;
}
Ok(())
}
}