Stripped out ui/api

src/main.rs

@@ -0,0 +1,91 @@
+extern crate diesel;
+#[macro_use]
+extern crate diesel_migrations;
+
+use std::env;
+use std::collections::HashSet;
+use std::sync::Arc;
+use serenity::client::Cache;
+use serenity::framework::StandardFramework;
+use serenity::http::Http;
+use serenity::prelude::*;
+use songbird::{SerenityInit, Songbird};
+
+use crate::bot::handler::Handler;
+
+mod bot;
+mod dnd;
+mod storage;
+
+#[tokio::main]
+async fn main() {
+  dotenv::dotenv().ok();
+  env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,siren=info"));
+  storage::init().await;
+
+  let token: String = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
+  let intents: GatewayIntents = GatewayIntents::all();
+
+  let http: Http = Http::new(&token);
+  let (owners, _bot_id) = match http.get_current_application_info().await {
+    Ok(info) => {
+      let mut owners: HashSet<serenity::model::id::UserId> = HashSet::new();
+      if let Some(team) = info.team {
+        owners.insert(team.owner_user_id);
+      } else {
+        owners.insert(info.owner.id);
+      }
+      match http.get_current_user().await {
+        Ok(bot) => (owners, bot.id),
+        Err(why) => panic!("Could not access the bot id: {:?}", why),
+      }
+    }
+    Err(why) => panic!("Could not access application info: {:?}", why),
+  };
+
+  let handler = match env::var("OPENAI_API_KEY") {
+    Ok(token) => {
+      log::info!("Loaded OpenAI token");
+      let default_model = env::var("OPENAI_API_MODEL").unwrap_or("gpt-3.5-turbo".to_string());
+      Handler {
+        oai: Some(bot::oai::OAI {
+          client: reqwest::Client::new(),
+          base_url: "https://api.openai.com/v1".to_string(),
+          service_url: "http://localhost:5000".to_string(),
+          max_attempts: 5,
+          token,
+          max_context_questions: 30,
+          max_tokens: 2048,
+          default_model,
+        }),
+      }
+    }
+    Err(err) => {
+      log::warn!("Could not load OpenAI token: {}", err);
+      Handler { oai: None }
+    }
+  };
+
+  let songbird = Songbird::serenity();
+
+  let mut client = Client::builder(token, intents)
+    .event_handler(handler)
+    .framework(StandardFramework::new().configure(|c| c.owners(owners)))
+    .register_songbird_with(Arc::clone(&songbird))
+    .await
+    .expect("Error creating client");
+
+  let _shard_manager = Arc::clone(&client.shard_manager);
+
+  // Start listening for events by starting a single shard
+  if let Err(why) = client.start_autosharded().await {
+    log::error!("Client error: {why:?}");
+  }
+
+}
+
+pub struct AppState {
+  pub http: Arc<Http>,
+  pub cache: Arc<Cache>,
+  pub songbird: Arc<Songbird>,
+}