Enum ProtocolMessage 

pub enum ProtocolMessage {
    Hello {
        protocol_version: u32,
        session: String,
    },
    Challenge {
        nonce: Vec<u8>,
    },
    Auth {
        pubkey: Vec<u8>,
        signature: Vec<u8>,
    },
    Established {
        path: SessionPath,
    },
    Register {
        username: String,
        machine: String,
        pubkey: Vec<u8>,
    },
    Join {
        channel: String,
        token: Option<String>,
    },
    Leave {
        channel: String,
    },
    Who {
        channel: Option<String>,
    },
    Admin(AdminOp),
    ChannelMsg {
        channel: String,
        from: SessionPath,
        payload: Payload,
    },
    Whisper {
        from: SessionPath,
        target: SessionPath,
        payload: Payload,
    },
    Presence {
        channel: Option<String>,
        sessions: Vec<SessionPath>,
    },
    Error(ProtocolError),
    ListChannels,
    ChannelList {
        channels: Vec<ChannelInfo>,
    },
    Joined {
        channel: String,
    },
    Ack {
        detail: Option<String>,
    },
    InviteToken {
        token: String,
    },
    Ping,
    Pong,
    ServerInfo {
        admin: bool,
    },
    ListMachines,
    MachineList {
        machines: Vec<MachineInfo>,
    },
    ListUsers,
    UserList {
        users: Vec<String>,
    },
    InviteList {
        invites: Vec<InviteInfo>,
    },
}

The versioned frame exchanged between a bridge and a central server.

Variants are append-only across protocol versions: later milestones may add variants but must not renumber or repurpose existing ones without a version bump (see negotiate_version).

Variants

Hello

Client → server on connect: advertise the protocol version and the session handle.

Fields

protocol_version: u32

The client’s protocol version.

session: String

The session handle (--as, defaulting to the repo/dir name).

Challenge

Server → client: a random nonce for the client to sign (challenge-response).

Fields

nonce: Vec<u8>

The random nonce.

Auth

Client → server: the machine public key and its signature over the nonce.

Fields

pubkey: Vec<u8>

The machine’s Ed25519 public key.

signature: Vec<u8>

The signature over the server’s nonce.

Established

Server → client: authentication succeeded; the resolved full participant path.

Fields

path: SessionPath

The resolved user/machine/session path.

Register

Client → server: claim a username and enroll this machine as its first key.

Fields

username: String

Username to claim.

machine: String

Machine name for this key.

pubkey: Vec<u8>

The machine’s Ed25519 public key.

Join

Client → server: join a channel, optionally redeeming an invite token.

Fields

channel: String

Channel name.

token: Option<String>

Invite token, if required.

Leave

Client → server: leave a channel.

Fields

channel: String

Channel name.

Who

Client → server: request presence, optionally scoped to one channel.

Fields

channel: Option<String>

Channel to scope to, or all subscribed channels if absent.

Admin(AdminOp)

Client → server: an admin / moderation operation.

ChannelMsg

A message addressed to all sessions subscribed to a channel.

Fields

channel: String

Channel name.

from: SessionPath

The sender’s full participant path.

payload: Payload

The message body.

Whisper

A direct message to exactly one session path.

Fields

from: SessionPath

The sender’s full participant path.

target: SessionPath

The single recipient’s full participant path.

payload: Payload

The message body.

Presence

Server → client: presence enumerated as full session paths.

Fields

channel: Option<String>

Channel the presence is scoped to, or server-wide if absent.

sessions: Vec<SessionPath>

The present sessions.

Error(ProtocolError)

A typed error surfaced to the peer that triggered it.

ListChannels

Client → server: request the channels visible to the authenticated user (discovery).

ChannelList

Server → client: the discovery result, already visibility-gated.

Fields

channels: Vec<ChannelInfo>

The channels the caller may see.

Joined

Server → client: a ProtocolMessage::Join succeeded; the session is now subscribed.

Fields

channel: String

The channel that was joined.

Ack

Server → client: a control / admin operation succeeded, with an optional human detail.

Fields

detail: Option<String>

A short human-readable detail (e.g. the affected name), if any.

InviteToken

Server → client: the token minted by an AdminOp::InviteCreate.

Fields

token: String

The opaque invite token.

Ping

Client → server: liveness keepalive; refreshes presence and draws a ProtocolMessage::Pong (the application-level realization of the §10 heartbeat, uniform across transports).

Pong

Server → client: keepalive acknowledgement.

ServerInfo

Server → client, immediately after ProtocolMessage::Established: the authenticated user’s server-wide role, so the bridge can gate its admin tools (DESIGN.md §7).

Fields

admin: bool

Whether the user is a server admin (on the serve-config allowlist).

ListMachines

Client → server: list the machines enrolled under the authenticated user.

MachineList

Server → client: the caller’s enrolled machines.

Fields

machines: Vec<MachineInfo>

The machines under the caller’s account.

ListUsers

Client → server: list the server’s users (server-admin only).

UserList

Server → client: the registered usernames (server-admin only).

Fields

users: Vec<String>

The registered usernames.

InviteList

Server → client: a channel’s outstanding invites (channel-admin audit, PRD-0011).

Fields

invites: Vec<InviteInfo>

The outstanding invites.

Trait Implementations

impl Clone for ProtocolMessage

fn clone(&self) -> ProtocolMessage

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProtocolMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProtocolMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ProtocolMessage

impl PartialEq for ProtocolMessage

fn eq(&self, other: &ProtocolMessage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProtocolMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProtocolMessage