Struct Member 

pub struct Member { /* private fields */ }

A handle to a member of a community — act on them directly. Obtained from Community::member or IncomingMessage::member.

Implementations

impl Member

pub fn npub(&self) -> &str

This member’s npub.

Examples found in repository

examples/moderation_bot.rs (line 49)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    // `.public()` lets anyone invite the bot into their community to moderate it.
    let bot = VectorBot::builder().nsec(nsec).public().build().await?;
    println!("Moderation bot online as {}", bot.npub());

    bot.on_event(|bot, event| async move {
        match event {
            // Greet new arrivals in the channel they joined.
            BotEvent::MemberJoin { channel_id, npub } => {
                let who = &npub[..npub.len().min(12)];
                let _ = bot.channel(channel_id).send(&format!("👋 Welcome, {who}!")).await;
            }

            // Screen community messages; ban posters of banned words (never admins or ourselves).
            BotEvent::Message(msg) if msg.is_group && !msg.is_mine() => {
                let lower = msg.text().to_lowercase();
                if !BANNED_WORDS.iter().any(|w| lower.contains(w)) {
                    return;
                }
                if let Some(member) = msg.member() {
                    if member.is_admin() {
                        return; // never moderate admins or the owner
                    }
                    match member.ban().await {
                        Ok(()) => println!("Banned {} for a banned word", member.npub()),
                        Err(e) => eprintln!("Couldn't ban {}: {e}", member.npub()),
                    }
                }
            }

            _ => {}
        }
    })
    .await?;

    Ok(())
}

examples/concordia.rs (line 223)

async fn main() -> vector_sdk::Result<()> {
    // Identity: VECTOR_NSEC override, else the persisted <data_dir>/identity.nsec
    // (created on first run by the builder). Public invite policy: any member can
    // pull the bot into their community with a direct invite (v1 or v2).
    let mut builder = VectorBot::builder().public();
    if let Ok(nsec) = std::env::var("VECTOR_NSEC") {
        builder = builder.nsec(nsec);
    }
    let bot = builder.build().await?;
    println!("── {NAME} online as {}", bot.npub());

    // Optional one-shot profile publish: upload the avatar plainly (avatars are
    // public) and publish the kind-0 with the bot flag. Existing fields are
    // carried forward by the profile pipeline, so this never clobbers. Deferred
    // until after listen() has connected the community relays — a kind-0 that
    // only reaches the login relays is invisible to community peers' clients.
    if let Ok(avatar_path) = std::env::var("CONCORDIA_AVATAR") {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(10)).await;
            let avatar_path = shellexpand_home(&avatar_path);
            println!("── uploading avatar {avatar_path}…");
            match bot.core().upload_public_image(&avatar_path).await {
                Ok(url) => {
                    let ok = bot.core().update_bot_profile(NAME, &url, "", ABOUT).await;
                    println!("── profile publish {}  avatar={url}", if ok { "✅" } else { "FAILED" });
                    if ok {
                        push_profile_to_communities().await;
                    }
                }
                Err(e) => eprintln!("!! avatar upload failed: {e}"),
            }
        });
    }

    // Optional invite link: join on first run; later runs come up with the
    // persisted memberships and need no arguments.
    if let Some(invite) = std::env::args().nth(1).or_else(|| std::env::var("VECTOR_INVITE").ok()) {
        println!("── joining via link…");
        match bot.core().join_community(&invite).await {
            Ok(summary) => {
                let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let ver = summary.get("version").and_then(|v| v.as_u64()).unwrap_or(0);
                println!("── joined \"{name}\"  protocol=v{ver}");
            }
            Err(e) => {
                eprintln!("!! join failed: {e}");
                return Err(e);
            }
        }
    }

    // Slash commands (Bot Interface Phase 1): registered here, published as the
    // kind-10304 manifest at listen start, invoked by PLAIN TEXT from any client.
    // Vector's `/` picker renders exactly this registry with argument hints; a
    // matched invocation is consumed before the legacy !bang console below.
    bot.command("help", "List everything Concordia can do").run(|ctx| async move {
        let _ = ctx.reply(HELP).await;
    });
    bot.command("ping", "Round-trip latency check").run(|ctx| async move {
        let _ = ctx.reply(format!("pong 🏓 ({} ms)", now_ms())).await;
    });
    bot.command("roll", "Roll a die")
        .int("sides", "How many sides (default 6)", false)
        .run(|ctx| async move {
            let sides = ctx.int("sides").unwrap_or(6).clamp(2, 1_000_000);
            let roll = (now_ms() as i64 % sides) + 1;
            let _ = ctx.reply(format!("🎲 rolled {roll} on a d{sides}")).await;
        });
    bot.command("announce", "Format a two-part announcement")
        .string("title", "Announcement title", true)
        .string("body", "Announcement body", true)
        .run(|ctx| async move {
            let title = ctx.str("title").unwrap_or("(untitled)").to_string();
            let body = ctx.str("body").unwrap_or_default().to_string();
            let _ = ctx.reply(format!("📣 {title}\n{body}")).await;
        });
    // ── Param-type test battery: every ArgType, solo and mixed ──────────────
    bot.command("typetest", "Echo back every param type, parsed")
        .string("text", "Any free text", true)
        .int("count", "A whole number", true)
        .number("ratio", "A decimal number", true)
        .flag("loud", "true or false", true)
        .user("who", "Any user (npub)", true)
        .choice("color", "Pick a color", ["red", "green", "blue"], true)
        .run(|ctx| async move {
            let report = format!(
                "typetest received:\n\
                 text   (String) = {:?}\n\
                 count  (Int)    = {}\n\
                 ratio  (Number) = {}\n\
                 loud   (Bool)   = {}\n\
                 who    (User)   = {}\n\
                 color  (Choice) = {}",
                ctx.str("text").unwrap_or_default(),
                ctx.int("count").unwrap_or_default(),
                ctx.number("ratio").unwrap_or_default(),
                ctx.flag("loud").unwrap_or_default(),
                ctx.str("who").unwrap_or_default(),
                ctx.str("color").unwrap_or_default(),
            );
            let _ = ctx.reply(report).await;
        });
    bot.command("greet", "Greet a member in a chosen style")
        .user("who", "Who to greet", true)
        .choice("style", "Greeting style", ["formal", "casual", "pirate"], true)
        .int("times", "Repeat 1-5 times (default 1)", false)
        .run(|ctx| async move {
            let who = ctx.str("who").unwrap_or_default().to_string();
            let line = match ctx.str("style").unwrap_or("casual") {
                "formal" => format!("Good day to you, {who}."),
                "pirate" => format!("Ahoy, {who}! 🏴‍☠️"),
                _ => format!("yo {who} 👋"),
            };
            let times = ctx.int("times").unwrap_or(1).clamp(1, 5) as usize;
            let _ = ctx.reply(vec![line; times].join("\n")).await;
        });
    bot.command("calc", "Do some arithmetic")
        .number("a", "First operand", true)
        .choice("op", "Operation", ["add", "sub", "mul", "div"], true)
        .number("b", "Second operand", true)
        .run(|ctx| async move {
            let a = ctx.number("a").unwrap_or_default();
            let b = ctx.number("b").unwrap_or_default();
            let answer = match ctx.str("op").unwrap_or_default() {
                "add" => Some(a + b),
                "sub" => Some(a - b),
                "mul" => Some(a * b),
                "div" if b != 0.0 => Some(a / b),
                _ => None,
            };
            let _ = ctx
                .reply(match answer {
                    Some(v) => format!("🧮 {v}"),
                    None => "cannot divide by zero".to_string(),
                })
                .await;
        });

    bot.command("reply", "Get a threaded reply to your message").run(|ctx| async move {
        let _ = ctx.reply("this is a threaded reply ✅ (I quoted your message)").await;
    });
    bot.command("react", "React to your message")
        .choice("emoji", "Which reaction", ["🔥", "👍", "❤️", "😂", "🫡"], false)
        .run(|ctx| async move {
            let emoji = ctx.str("emoji").unwrap_or("🔥").to_string();
            log_err("react", ctx.msg.react(&emoji).await.map(|_| String::new()));
        });
    bot.command("edit", "Watch me send then edit a message").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("editing this in one second…").await {
            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
        }
    });
    bot.command("delete", "Watch a message self-destruct").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("…this message will self-destruct").await {
            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
        }
    });
    bot.command("typing", "Emit a typing indicator").run(|ctx| async move {
        log_err("typing", ctx.msg.channel().typing().await.map(|_| String::new()));
    });
    bot.command("file", "Receive a small encrypted attachment").run(|ctx| async move {
        send_test_file(&ctx.msg.channel()).await;
    });
    bot.command("members", "The folded member list").run(|ctx| async move {
        if let Some(community) = ctx.msg.community() {
            let members = community.members().await;
            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
            let _ = ctx.reply(format!("{} member(s): {}", members.len(), list.join(", "))).await;
        } else {
            let _ = ctx.reply("not in a community here").await;
        }
    });
    bot.command("channels", "The channels I can see here").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!channels").await;
    });
    bot.command("caps", "My capabilities here (roles engine)").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!caps").await;
    });
    bot.command("roles", "The community roster").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!roles").await;
    });
    bot.command("info", "Community protocol + ownership summary").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!info").await;
    });
    bot.command("whoami", "My npub and this channel id").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!whoami").await;
    });
    bot.command("reconnect", "Bounce my relay sockets (reconnect drill)").run(|ctx| async move {
        let bounced = bounce_community_relays().await;
        let _ = ctx.reply(format!("bounced {bounced} relay socket(s) — /ping to test the post-reconnect subscription")).await;
    });

    // The join snapshot folds only owner-authored channels; admin-created ones
    // arrive on the first control follow, so re-print once that has landed.
    print_channels(&bot, "channels visible (startup)").await;
    {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(25)).await;
            print_channels(&bot, "channels visible (after control follow)").await;
        });
    }
    println!("── listening. Message me `!help` from your client.\n");

    bot.on_event(|bot, event| async move {
        match event {
            BotEvent::Message(msg) => {
                if msg.is_mine() {
                    return; // never react to our own sends
                }
                let author = short(msg.message.npub.as_deref().unwrap_or("?"));
                let text = msg.text().trim().to_string();
                println!("[MSG]    {author}: {text}");

                // Command console — each arm fires a distinct SDK send-path.
                let ch = msg.channel();
                match text.as_str() {
                    "!help" => reply(&msg, HELP).await,
                    "!ping" => reply(&msg, &format!("pong 🏓 ({} ms)", now_ms())).await,
                    "!reply" => reply(&msg, "this is a threaded reply ✅ (I quoted your message)").await,
                    "!react" => log_err("react", msg.react("🔥").await.map(|_| String::new())),
                    "!typing" => log_err("typing", ch.typing().await.map(|_| String::new())),
                    "!edit" => {
                        if let Ok(id) = ch.send("editing this in one second…").await {
                            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
                        }
                    }
                    "!delete" => {
                        if let Ok(id) = ch.send("…this message will self-destruct").await {
                            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
                        }
                    }
                    "!file" => send_test_file(&ch).await,
                    "!members" => {
                        if let Some(community) = msg.community() {
                            let members = community.members().await;
                            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
                            reply(&msg, &format!("{} member(s): {}", members.len(), list.join(", "))).await;
                        } else {
                            reply(&msg, "not in a community here").await;
                        }
                    }
                    "!reconnect" => {
                        // Ops/repro tool: bounce this bot's community relay sockets (a
                        // relay restart or idle drop in miniature) — then a !ping proves
                        // whether the subscription survived the fresh AUTH gate.
                        let bounced = bounce_community_relays().await;
                        reply(&msg, &format!("bounced {bounced} relay socket(s) — send !ping to test the post-reconnect subscription")).await;
                    }
                    "!channels" | "!info" | "!caps" | "!roles" | "!whoami" => diagnostics(&bot, &msg, &text).await,
                    other if other.starts_with('!') => reply(&msg, &format!("unknown command `{other}` — try !help")).await,
                    // Non-command chatter is logged above but never replied to, so
                    // the bot can sit in a busy community without spamming echoes.
                    _ => {}
                }
            }
            BotEvent::MessageUpdate { message, .. } => {
                println!("[UPDATE] {} → \"{}\"  ({} reaction(s))", short(message.npub.as_deref().unwrap_or("?")), message.content, message.reactions.len());
            }
            BotEvent::Delete { message_id, .. } => println!("[DELETE] message {}", short(&message_id)),
            BotEvent::MemberJoin { npub, .. } => println!("[JOIN]   {}", short(&npub)),
            BotEvent::MemberLeave { npub, .. } => println!("[LEAVE]  {}", short(&npub)),
            BotEvent::Typing { npub, .. } => println!("[TYPING] {}", short(&npub)),
            BotEvent::Invite { community_id } => println!("[INVITE] for community {}", short(&community_id)),
            BotEvent::Removed { community_id } => println!("[REMOVED] from community {} — I was kicked/banned", short(&community_id)),
        }
    })
    .await?;

    Ok(())
}

pub fn community_id(&self) -> &str

The id of the community this handle is scoped to.

pub async fn kick(&self) -> Result<()>

Cooperatively kick them (they can rejoin). Requires KICK + outranking them.

pub async fn ban(&self) -> Result<()>

Ban them (terminal; in a private community this triggers a read-cut rekey). Requires BAN.

Examples found in repository

examples/moderation_bot.rs (line 48)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    // `.public()` lets anyone invite the bot into their community to moderate it.
    let bot = VectorBot::builder().nsec(nsec).public().build().await?;
    println!("Moderation bot online as {}", bot.npub());

    bot.on_event(|bot, event| async move {
        match event {
            // Greet new arrivals in the channel they joined.
            BotEvent::MemberJoin { channel_id, npub } => {
                let who = &npub[..npub.len().min(12)];
                let _ = bot.channel(channel_id).send(&format!("👋 Welcome, {who}!")).await;
            }

            // Screen community messages; ban posters of banned words (never admins or ourselves).
            BotEvent::Message(msg) if msg.is_group && !msg.is_mine() => {
                let lower = msg.text().to_lowercase();
                if !BANNED_WORDS.iter().any(|w| lower.contains(w)) {
                    return;
                }
                if let Some(member) = msg.member() {
                    if member.is_admin() {
                        return; // never moderate admins or the owner
                    }
                    match member.ban().await {
                        Ok(()) => println!("Banned {} for a banned word", member.npub()),
                        Err(e) => eprintln!("Couldn't ban {}: {e}", member.npub()),
                    }
                }
            }

            _ => {}
        }
    })
    .await?;

    Ok(())
}

pub async fn unban(&self) -> Result<()>

Lift a ban.

pub async fn grant_admin(&self) -> Result<()>

Grant them the @admin role (requires MANAGE_ROLES).

pub async fn revoke_admin(&self) -> Result<()>

Revoke their @admin role.

pub async fn profile(&self) -> Option<SlimProfile>

Fetch this member’s profile.

pub fn is_owner(&self) -> bool

Whether this member is the community owner.

pub fn is_admin(&self) -> bool

Whether this member is an admin (the owner counts as admin).

Examples found in repository

examples/moderation_bot.rs (line 45)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    // `.public()` lets anyone invite the bot into their community to moderate it.
    let bot = VectorBot::builder().nsec(nsec).public().build().await?;
    println!("Moderation bot online as {}", bot.npub());

    bot.on_event(|bot, event| async move {
        match event {
            // Greet new arrivals in the channel they joined.
            BotEvent::MemberJoin { channel_id, npub } => {
                let who = &npub[..npub.len().min(12)];
                let _ = bot.channel(channel_id).send(&format!("👋 Welcome, {who}!")).await;
            }

            // Screen community messages; ban posters of banned words (never admins or ourselves).
            BotEvent::Message(msg) if msg.is_group && !msg.is_mine() => {
                let lower = msg.text().to_lowercase();
                if !BANNED_WORDS.iter().any(|w| lower.contains(w)) {
                    return;
                }
                if let Some(member) = msg.member() {
                    if member.is_admin() {
                        return; // never moderate admins or the owner
                    }
                    match member.ban().await {
                        Ok(()) => println!("Banned {} for a banned word", member.npub()),
                        Err(e) => eprintln!("Couldn't ban {}: {e}", member.npub()),
                    }
                }
            }

            _ => {}
        }
    })
    .await?;

    Ok(())
}

Trait Implementations

impl Clone for Member

fn clone(&self) -> Member

Returns a duplicate of the value.

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

Performs copy-assignment from source.