ChanServ: add SET SUCCESSOR with founder inheritance

SET <#channel> SUCCESSOR <account>|OFF names an account that inherits the
channel if the founder's account is dropped or expires, instead of the
channel being released. Adds a ChannelInfo.successor field + event, and
centralises the founder-gone channel release into a single
release_founded_channels store method used by DROP, expiry, and the
gossip account-gone path so all three transfer consistently.

src/engine/db/channel.rs

@@ -11,7 +11,7 @@ impl Db {
         self.log
             .append(Event::ChannelRegistered { name: name.to_string(), founder: founder.to_string(), ts })
             .map_err(|_| ChanError::Internal)?;
-        self.channels.insert(k, ChannelInfo { name: name.to_string(), founder: founder.to_string(), ts, lock_on: String::new(), lock_off: String::new(), access: Vec::new(), akick: Vec::new(), desc: String::new(), entrymsg: String::new(), settings: ChanSettings::default(), topic: String::new(), suspension: None, assigned_bot: None , kickers: KickerSettings::default() , badwords: Vec::new(), badwords_rev: 0 , triggers: Vec::new(), triggers_rev: 0, last_used: ts, noexpire: false, expiry_warned: false, oper_note: None });
+        self.channels.insert(k, ChannelInfo { name: name.to_string(), founder: founder.to_string(), ts, lock_on: String::new(), lock_off: String::new(), access: Vec::new(), akick: Vec::new(), successor: None, desc: String::new(), entrymsg: String::new(), settings: ChanSettings::default(), topic: String::new(), suspension: None, assigned_bot: None , kickers: KickerSettings::default() , badwords: Vec::new(), badwords_rev: 0 , triggers: Vec::new(), triggers_rev: 0, last_used: ts, noexpire: false, expiry_warned: false, oper_note: None });
         Ok(())
     }
 
@@ -134,6 +134,46 @@ impl Db {
         Ok(())
     }
 
+    /// Set (or clear, with None) `channel`'s successor account.
+    pub fn set_successor(&mut self, channel: &str, successor: Option<&str>) -> Result<(), ChanError> {
+        let k = key(channel);
+        if !self.channels.contains_key(&k) {
+            return Err(ChanError::NoChannel);
+        }
+        let successor = successor.map(|s| s.to_string());
+        self.log
+            .append(Event::ChannelSuccessorSet { channel: channel.to_string(), successor: successor.clone() })
+            .map_err(|_| ChanError::Internal)?;
+        self.channels.get_mut(&k).unwrap().successor = successor;
+        Ok(())
+    }
+
+    /// The successor account set on `channel`, if any.
+    pub fn channel_successor(&self, channel: &str) -> Option<String> {
+        self.channels.get(&key(channel)).and_then(|c| c.successor.clone())
+    }
+
+    /// Release the channels founded by `account` because the account is going
+    /// away: one with a valid successor is transferred to them, the rest are
+    /// dropped. Returns (transferred as (channel, successor), dropped channels).
+    pub fn release_founded_channels(&mut self, account: &str) -> (Vec<(String, String)>, Vec<String>) {
+        let (mut transferred, mut dropped) = (Vec::new(), Vec::new());
+        for chan in self.channels_owned_by(account) {
+            let successor = self.channel_successor(&chan).filter(|s| !s.eq_ignore_ascii_case(account) && self.exists(s));
+            match successor {
+                Some(s) if self.set_founder(&chan, &s).is_ok() => {
+                    let _ = self.set_successor(&chan, None); // consumed
+                    transferred.push((chan, s));
+                }
+                _ => {
+                    let _ = self.drop_channel(&chan);
+                    dropped.push(chan);
+                }
+            }
+        }
+        (transferred, dropped)
+    }
+
     /// Set `channel`'s description (empty clears it).
     pub fn set_desc(&mut self, channel: &str, desc: &str) -> Result<(), ChanError> {
         let k = key(channel);

src/engine/db/event.rs

@@ -39,6 +39,7 @@ pub enum Event {
     ChannelAkickAdd { channel: String, mask: String, reason: String },
     ChannelAkickDel { channel: String, mask: String },
     ChannelFounderSet { channel: String, founder: String },
+    ChannelSuccessorSet { channel: String, successor: Option<String> },
     ChannelDescSet { channel: String, desc: String },
     ChannelEntryMsgSet { channel: String, msg: String },
     ChannelSettingsSet { channel: String, settings: ChanSettings },
@@ -184,6 +185,7 @@ impl Event {
             | Event::ChannelAkickAdd { .. }
             | Event::ChannelAkickDel { .. }
             | Event::ChannelFounderSet { .. }
+            | Event::ChannelSuccessorSet { .. }
             | Event::ChannelDescSet { .. }
             | Event::ChannelEntryMsgSet { .. }
             | Event::ChannelSettingsSet { .. }
@@ -337,7 +339,7 @@ pub(crate) fn apply(accounts: &mut HashMap<String, Account>, channels: &mut Hash
             grouped.remove(&key(&nick));
         }
         Event::ChannelRegistered { name, founder, ts } => {
-            channels.insert(key(&name), ChannelInfo { name, founder, ts, lock_on: String::new(), lock_off: String::new(), access: Vec::new(), akick: Vec::new(), desc: String::new(), entrymsg: String::new(), settings: ChanSettings::default(), topic: String::new(), suspension: None, assigned_bot: None , kickers: KickerSettings::default() , badwords: Vec::new(), badwords_rev: 0 , triggers: Vec::new(), triggers_rev: 0, last_used: ts, noexpire: false, expiry_warned: false, oper_note: None });
+            channels.insert(key(&name), ChannelInfo { name, founder, ts, lock_on: String::new(), lock_off: String::new(), access: Vec::new(), akick: Vec::new(), successor: None, desc: String::new(), entrymsg: String::new(), settings: ChanSettings::default(), topic: String::new(), suspension: None, assigned_bot: None , kickers: KickerSettings::default() , badwords: Vec::new(), badwords_rev: 0 , triggers: Vec::new(), triggers_rev: 0, last_used: ts, noexpire: false, expiry_warned: false, oper_note: None });
         }
         Event::ChannelDropped { name } => {
             channels.remove(&key(&name));
@@ -375,6 +377,11 @@ pub(crate) fn apply(accounts: &mut HashMap<String, Account>, channels: &mut Hash
                 c.founder = founder;
             }
         }
+        Event::ChannelSuccessorSet { channel, successor } => {
+            if let Some(c) = channels.get_mut(&key(&channel)) {
+                c.successor = successor;
+            }
+        }
         Event::ChannelDescSet { channel, desc } => {
             if let Some(c) = channels.get_mut(&key(&channel)) {
                 c.desc = desc;

src/engine/db/mod.rs

@@ -359,6 +359,10 @@ pub struct ChannelInfo {
     pub access: Vec<ChanAccess>,
     #[serde(default)]
     pub akick: Vec<ChanAkick>,
+    // Account that inherits the channel if the founder's account is dropped or
+    // expires; None means the channel is released instead.
+    #[serde(default)]
+    pub successor: Option<String>,
     // Free-text description, shown in INFO.
     #[serde(default)]
     pub desc: String,

src/engine/db/store.rs

@@ -447,6 +447,12 @@ impl Store for Db {
     fn set_entrymsg(&mut self, channel: &str, msg: &str) -> Result<(), ChanError> {
         Db::set_entrymsg(self, channel, msg)
     }
+    fn set_successor(&mut self, channel: &str, successor: Option<&str>) -> Result<(), ChanError> {
+        Db::set_successor(self, channel, successor)
+    }
+    fn release_founded_channels(&mut self, account: &str) -> (Vec<(String, String)>, Vec<String>) {
+        Db::release_founded_channels(self, account)
+    }
     fn set_founder(&mut self, channel: &str, account: &str) -> Result<(), ChanError> {
         Db::set_founder(self, channel, account)
     }

src/engine/mod.rs

@@ -440,17 +440,21 @@ impl Engine {
     // channels it founded locally — their founder identity no longer exists here.
     fn handle_account_gone(&mut self, account: &str, reason: &str) {
         let victims = self.network.uids_logged_into(account);
-        let orphaned = self.db.channels_owned_by(account);
-        for chan in &orphaned {
-            let _ = self.db.drop_channel(chan);
-        }
+        // A channel with a valid successor is inherited rather than released.
+        let (inherited, orphaned) = self.db.release_founded_channels(account);
         let (cs, ns) = (self.chan_service.clone(), self.nick_service.clone());
-        // Release the registered mode on each dropped channel.
+        // Release the registered mode on each dropped (not inherited) channel.
         for chan in &orphaned {
             if let Some(cs) = &cs {
                 self.emit_irc(NetAction::ChannelMode { from: cs.clone(), channel: chan.clone(), modes: "-r".to_string() });
             }
         }
+        // Tell any online successor they inherited a channel.
+        for (chan, s) in &inherited {
+            if let (Some(ns), Some(uid)) = (&ns, self.network.uids_logged_into(s).into_iter().next()) {
+                self.emit_irc(NetAction::Notice { from: ns.clone(), to: uid, text: format!("You are now the founder of \x02{chan}\x02 (inherited from \x02{account}\x02).") });
+            }
+        }
         // Log out and inform each local session that held the name.
         for uid in victims {
             self.network.clear_account(&uid);
@@ -1088,6 +1092,10 @@ fn audit_summary(event: &db::Event) -> Option<String> {
         ChannelRegistered { name, founder, .. } => format!("registered channel \x02{name}\x02 (founder \x02{founder}\x02)"),
         ChannelDropped { name } => format!("dropped channel \x02{name}\x02"),
         ChannelFounderSet { channel, founder } => format!("set founder of \x02{channel}\x02 to \x02{founder}\x02"),
+        ChannelSuccessorSet { channel, successor } => match successor {
+            Some(s) => format!("set successor of \x02{channel}\x02 to \x02{s}\x02"),
+            None => format!("cleared the successor of \x02{channel}\x02"),
+        },
         ChannelAccessAdd { channel, account, level } => format!("set \x02{account}\x02 to {level} on \x02{channel}\x02"),
         ChannelAccessDel { channel, account } => format!("removed \x02{account}\x02 from \x02{channel}\x02 access"),
         ChannelAkickAdd { channel, mask, reason } => format!("added akick \x02{mask}\x02 on \x02{channel}\x02 ({reason})"),

src/engine/tests.rs

@@ -903,6 +903,37 @@
         assert!(!mode(&out, "+q 000AAAAAC"), "non-founder cannot grant owner: {out:?}");
     }
 
+    // ChanServ SET SUCCESSOR: the successor inherits the channel when the founder
+    // account is dropped, instead of the channel being released.
+    #[test]
+    fn chanserv_successor_inherits_on_drop() {
+        use echo_chanserv::ChanServ;
+        use echo_nickserv::NickServ;
+        let path = std::env::temp_dir().join("echo-cssucc.jsonl");
+        let _ = std::fs::remove_file(&path);
+        let mut db = Db::open(&path, "42S");
+        db.scram_iterations = 4096;
+        db.register("alice", "sesame", None).unwrap();
+        db.register("bob", "pw", None).unwrap();
+        db.register_channel("#c", "alice").unwrap();
+        let mut e = Engine::new(
+            vec![
+                Box::new(NickServ { uid: "42SAAAAAA".into(), guest_nick: "Guest".into(), guest_seq: 0 }),
+                Box::new(ChanServ { uid: "42SAAAAAB".into() }),
+            ],
+            db,
+        );
+        e.handle(NetEvent::UserConnect { uid: "000AAAAAB".into(), nick: "alice".into(), host: "h".into(), ip: "0.0.0.0".into() });
+        e.handle(NetEvent::Privmsg { from: "000AAAAAB".into(), to: "42SAAAAAA".into(), text: "IDENTIFY sesame".into() });
+        let out = e.handle(NetEvent::Privmsg { from: "000AAAAAB".into(), to: "42SAAAAAB".into(), text: "SET #c SUCCESSOR bob".into() });
+        assert!(out.iter().any(|a| matches!(a, NetAction::Notice { text, .. } if text.contains("Successor") && text.contains("bob"))), "successor set: {out:?}");
+
+        // alice drops her account -> #c is inherited by bob, not released.
+        e.handle(NetEvent::Privmsg { from: "000AAAAAB".into(), to: "42SAAAAAA".into(), text: "DROP sesame".into() });
+        assert_eq!(e.db.channel("#c").map(|c| c.founder.clone()), Some("bob".to_string()), "channel inherited by the successor");
+        assert!(e.db.account("alice").is_none(), "the dropped account is gone");
+    }
+
     // BotServ BOT ADD/LIST is oper-gated (Priv::Admin) and the bot is remembered.
     #[test]
     fn botserv_bot_add_list_is_oper_gated() {