huskies: merge 472_story_discord_chat_transport

server/src/main.rs

@@ -339,12 +339,14 @@ async fn main() -> Result<(), std::io::Error> {
     // before watcher_tx is moved into AppContext.
     let watcher_rx_for_whatsapp = watcher_tx.subscribe();
     let watcher_rx_for_slack = watcher_tx.subscribe();
+    let watcher_rx_for_discord = watcher_tx.subscribe();
     // Wrap perm_rx in Arc<Mutex> so it can be shared with both the WebSocket
     // handler (via AppContext) and the Matrix bot.
     let perm_rx = Arc::new(tokio::sync::Mutex::new(perm_rx));
     let perm_rx_for_bot = Arc::clone(&perm_rx);
     let perm_rx_for_whatsapp = Arc::clone(&perm_rx);
     let perm_rx_for_slack = Arc::clone(&perm_rx);
+    let perm_rx_for_discord = Arc::clone(&perm_rx);
 
     // Capture project root, agents Arc, and reconciliation sender before ctx
     // is consumed by build_routes.
@@ -441,9 +443,49 @@ async fn main() -> Result<(), std::io::Error> {
             })
         });
 
+    // Build Discord context if bot.toml configures transport = "discord".
+    let discord_ctx: Option<Arc<chat::transport::discord::DiscordContext>> = startup_root
+        .as_ref()
+        .and_then(|root| chat::transport::matrix::BotConfig::load(root))
+        .filter(|cfg| cfg.transport == "discord")
+        .map(|cfg| {
+            let transport = Arc::new(chat::transport::discord::DiscordTransport::new(
+                cfg.discord_bot_token.clone().unwrap_or_default(),
+            ));
+            let bot_name = cfg
+                .display_name
+                .clone()
+                .unwrap_or_else(|| "Assistant".to_string());
+            let root = startup_root.clone().unwrap();
+            let history = chat::transport::discord::load_discord_history(&root);
+            let channel_ids: std::collections::HashSet<String> =
+                cfg.discord_channel_ids.iter().cloned().collect();
+            let allowed_users: std::collections::HashSet<String> =
+                cfg.discord_allowed_users.iter().cloned().collect();
+            Arc::new(chat::transport::discord::DiscordContext {
+                bot_token: cfg.discord_bot_token.clone().unwrap_or_default(),
+                transport,
+                project_root: root,
+                agents: Arc::clone(&startup_agents),
+                bot_name,
+                bot_user_id: "discord-bot".to_string(),
+                ambient_rooms: Arc::new(std::sync::Mutex::new(std::collections::HashSet::new())),
+                history: std::sync::Arc::new(tokio::sync::Mutex::new(history)),
+                history_size: cfg.history_size,
+                channel_ids,
+                allowed_users,
+                perm_rx: perm_rx_for_discord,
+                pending_perm_replies: Arc::new(tokio::sync::Mutex::new(
+                    std::collections::HashMap::new(),
+                )),
+                permission_timeout_secs: cfg.permission_timeout_secs,
+            })
+        });
+
     // Build a best-effort shutdown notifier for webhook-based transports.
     //
     // • Slack: channels are fixed at startup (channel_ids from bot.toml).
+    // • Discord: channels are fixed at startup (channel_ids from bot.toml).
     // • WhatsApp: active senders are tracked at runtime in ambient_rooms.
     //   We keep the WhatsApp context Arc so we can read the rooms at shutdown.
     // • Matrix: the bot task manages its own announcement via matrix_shutdown_tx.
@@ -454,6 +496,13 @@ async fn main() -> Result<(), std::io::Error> {
             channels,
             ctx.bot_name.clone(),
         )))
+    } else if let Some(ref ctx) = discord_ctx {
+        let channels: Vec<String> = ctx.channel_ids.iter().cloned().collect();
+        Some(Arc::new(BotShutdownNotifier::new(
+            Arc::clone(&ctx.transport) as Arc<dyn crate::chat::ChatTransport>,
+            channels,
+            ctx.bot_name.clone(),
+        )))
     } else {
         None
     };
@@ -496,6 +545,18 @@ async fn main() -> Result<(), std::io::Error> {
             notifier.notify_startup().await;
         });
     }
+    if let Some(ref ctx) = discord_ctx {
+        let transport = Arc::clone(&ctx.transport) as Arc<dyn crate::chat::ChatTransport>;
+        let bot_name = ctx.bot_name.clone();
+        let channels: Vec<String> = ctx.channel_ids.iter().cloned().collect();
+        tokio::spawn(async move {
+            if channels.is_empty() {
+                return;
+            }
+            let notifier = crate::rebuild::BotShutdownNotifier::new(transport, channels, bot_name);
+            notifier.notify_startup().await;
+        });
+    }
 
     // Watch channel: signals the Matrix bot task to send a shutdown announcement.
     // `None` initial value means "server is running".
@@ -559,6 +620,21 @@ async fn main() -> Result<(), std::io::Error> {
     } else {
         drop(watcher_rx_for_slack);
     }
+    if let (Some(ctx), Some(root)) = (&discord_ctx, &startup_root) {
+        // Spawn the Discord Gateway WebSocket listener.
+        chat::transport::discord::gateway::spawn_gateway(Arc::clone(ctx));
+
+        // Spawn stage-transition notification listener for Discord.
+        let channel_ids: Vec<String> = ctx.channel_ids.iter().cloned().collect();
+        chat::transport::matrix::notifications::spawn_notification_listener(
+            Arc::clone(&ctx.transport) as Arc<dyn crate::chat::ChatTransport>,
+            move || channel_ids.clone(),
+            watcher_rx_for_discord,
+            root.clone(),
+        );
+    } else {
+        drop(watcher_rx_for_discord);
+    }
 
     // On startup:
     // 1. Reconcile any stories whose agent work was committed while the server was