Implement token-based context usage in chat UI

- Replace simple message count with token-based calculation
- Add token estimation function (4 chars ≈ 1 token)
- Set MAX_TOKENS to 5000 and MIN_DISPLAY_PERCENTAGE to 20
- Update context usage display to show token count percentage
- Track tokens for both user and assistant messages
- Handle server-provided context usage as ratio of MAX_TOKENS

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "botserver",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

src/main.rs

@@ -56,7 +56,93 @@ use crate::web_server::{bot_index, index, static_files};
 use crate::whatsapp::whatsapp_webhook_verify;
 use crate::whatsapp::WhatsAppAdapter;
 
+if args.len() > 1 {
+let command = &args[1];
+match command.as_str() {
+async fn main() -> std::io::Result<()> {
+trace!("Application starting");
+let args: Vec<String> = std::env::args().collect();
+trace!("Command line arguments: {:?}", args);
+
+if args.len() > 1 {
+let command = &args[1];
+trace!("Processing command: {}", command);
+match command.as_str() {
+let args: Vec<String> = std::env::args().collect();
+
+if args.len() > 1 {
+let command = &args[1];
+match command.as_str() {
 #[tokio::main]
+async fn main() -> std::io::Result<()> {
+trace!("Application starting");
+let args: Vec<String> = std::env::args().collect();
+trace!("Command line arguments: {:?}", args);
+
+if args.len() > 1 {
+let command = &args[1];
+trace!("Processing command: {}", command);
+match command.as_str() {
+"install" | "remove" | "list" | "status" | "start" | "stop" | "restart" | "--help" | "-h" => {
+match package_manager::cli::run().expect("Failed to initialize Drive");
+let drive = init_drive(&config.minio)
+.await
+.expect("Failed to initialize Drive");
+trace!("MinIO drive initialized successfully");
+.await
+.expect("Failed to initialize Drive");
+let drive = init_drive(&config.minio)
+.await
+.expect("Failed to initialize Drive");
+trace!("MinIO drive initialized successfully"); {
+Ok(_) => return Ok(()),
+Err(e) => {
+eprintln!("CLI error: {}", e);
+return Err(std::io::Error::new(
+std::io::ErrorKind::Other,
+format!("CLI command failed: {}", e),
+));
+}
+}
+}
+_ => {
+eprintln!("Unknown command: {}", command);
+eprintln!("Run 'botserver --help' for usage information");
+return Err(std::io::Error::new(
+std::io::ErrorKind::InvalidInput,
+format!("Unknown command: {}", command),
+));
+}
+}
+}
+
+if args.len() > 1 {
+let command = &args[1];
+match command.as_str() {
+async fn main() -> std::io::Result<()> {
+trace!("Application starting");
+let args: Vec<String> = std::env::args().collect();
+trace!("Command line arguments: {:?}", args);
+
+if args.len() > 1 {
+let command = &args[1];
+trace!("Processing command: {}", command);
+match command.as_str() {
+let args: Vec<String> = std::env::args().collect();
+
+if args.len() > 1 {
+let command = &args[1];
+match command.as_str() {
+#[tokio::main]
+async fn main() -> std::io::Result<()> {
+trace!("Starting main function");
+let args: Vec<String> = std::env::args().collect();
+trace!("Command line arguments: {:?}", args);
+
+if args.len() > 1 {
+let command = &args[1];
+trace!("Processing command: {}", command);
+match command.as_str() {
 async fn main() -> std::io::Result<()> {
     let args: Vec<String> = std::env::args().collect();
 
@@ -85,12 +171,60 @@ async fn main() -> std::io::Result<()> {
         }
     }
 
-    dotenv().ok();
+    info!("Starting BotServer bootstrap process");
+dotenv().ok();
+env_logger::Builder::from_env(env_logger::Env::default_filter_or("info")).init();
+trace!("Environment variables loaded and logger initialized");
+
+info!("Starting BotServer bootstrap process");
+trace!("Initializing bootstrap manager");
+env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+info!("Starting BotServer bootstrap process");
+dotenv().ok();
+env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+trace!("Environment variables loaded and logger initialized");
+
+info!("Starting BotServer bootstrap process");
+trace!("Initializing bootstrap manager");
+
+info!("Starting BotServer bootstrap process");
+dotenv().ok();
+env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+trace!("Environment variables loaded and logger initialized");
+
+info!("Starting BotServer bootstrap process");
+trace!("Initializing bootstrap manager");
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
     info!("Starting BotServer bootstrap process");
 
-    let install_mode = if args.contains(&"--container".to_string()) {
+    InstallMode::Container
+} else {
+InstallMode::Local
+};
+
+let tenant = if let Some(idx) = args.iter().position(|a| a == "--tenant") {
+args.get(idx + 1).cloned()
+} else {
+None
+};
+let install_mode = if args.contains(&"--container".to_string()) {
+trace!("Running in container mode");
+InstallMode::Container
+} else {
+trace!("Running in local mode");
+InstallMode::Local
+};
+
+let tenant = if let Some(idx) = args.iter().position(|a| a == "--tenant") {
+let tenant = args.get(idx + 1).cloned();
+trace!("Tenant specified: {:?}", tenant);
+tenant
+} else {
+trace!("No tenant specified");
+None
+};
         InstallMode::Container
     } else {
         InstallMode::Local
@@ -103,7 +237,28 @@ async fn main() -> std::io::Result<()> {
     };
 
     let mut bootstrap = BootstrapManager::new(install_mode.clone(), tenant.clone());
-    let cfg = match bootstrap.bootstrap() {
+    info!("Bootstrap completed successfully, configuration loaded from database");
+config
+let cfg = match bootstrap.bootstrap() {
+Ok(config) => {
+info!("Bootstrap completed successfully, configuration loaded from database");
+trace!("Bootstrap config: {:?}", config);
+config
+Ok(config) => {
+info!("Bootstrap completed successfully, configuration loaded from database");
+config
+let cfg = match bootstrap.bootstrap() {
+Ok(config) => {
+info!("Bootstrap completed successfully, configuration loaded from database");
+trace!("Bootstrap config: {:?}", config);
+config
+info!("Bootstrap completed successfully, configuration loaded from database");
+config
+let cfg = match bootstrap.bootstrap() {
+Ok(config) => {
+info!("Bootstrap completed successfully, configuration loaded from database");
+trace!("Bootstrap config: {:?}", config);
+config
         Ok(config) => {
             info!("Bootstrap completed successfully, configuration loaded from database");
             config
@@ -131,10 +286,30 @@ async fn main() -> std::io::Result<()> {
         log::warn!("Failed to upload templates to MinIO: {}", e);
     }
 
-    let config = std::sync::Arc::new(cfg.clone());
+    info!("Establishing database connection to {}", cfg.database_url());
+let config = std::sync::Arc::new(cfg.clone());
+trace!("Configuration loaded: {:?}", cfg);
+
+info!("Establishing database connection to {}", cfg.database_url());
+trace!("Database URL: {}", cfg.database_url());
 
     info!("Establishing database connection to {}", cfg.database_url());
     let db_pool = match diesel::Connection::establish(&cfg.database_url()) {
+Ok(conn) => {
+trace!("Database connection established successfully");
+Arc::new(Mutex::new(conn))
+}
+Ok(conn) => Arc::new(Mutex::new(conn)),
+let db_pool = match diesel::Connection::establish(&cfg.database_url()) {
+Ok(conn) => {
+trace!("Database connection established successfully");
+Arc::new(Mutex::new(conn))
+}
+let db_pool = match diesel::Connection::establish(&cfg.database_url()) {
+Ok(conn) => {
+trace!("Database connection established successfully");
+Arc::new(Mutex::new(conn))
+}
         Ok(conn) => Arc::new(Mutex::new(conn)),
         Err(e) => {
             log::error!("Failed to connect to main database: {}", e);
@@ -156,6 +331,21 @@ async fn main() -> std::io::Result<()> {
         .or_else(|_| std::env::var("REDIS_URL"))
         .unwrap_or_else(|_| "redis://localhost:6379".to_string());
     let redis_client = match redis::Client::open(cache_url.as_str()) {
+Ok(client) => {
+trace!("Redis client created successfully");
+Some(Arc::new(client))
+}
+Ok(client) => Some(Arc::new(client)),
+let redis_client = match redis::Client::open(cache_url.as_str()) {
+Ok(client) => {
+trace!("Redis client created successfully");
+Some(Arc::new(client))
+}
+let redis_client = match redis::Client::open(cache_url.as_str()) {
+Ok(client) => {
+trace!("Redis client created successfully");
+Some(Arc::new(client))
+}
         Ok(client) => Some(Arc::new(client)),
         Err(e) => {
             log::warn!("Failed to connect to Redis: Redis URL did not parse- {}", e);
@@ -183,7 +373,12 @@ async fn main() -> std::io::Result<()> {
     let tool_api = Arc::new(tools::ToolApi::new());
 
     info!("Initializing MinIO drive at {}", cfg.minio.server);
-    let drive = init_drive(&config.minio)
+    .await
+.expect("Failed to initialize Drive");
+let drive = init_drive(&config.minio)
+.await
+.expect("Failed to initialize Drive");
+trace!("MinIO drive initialized successfully");
         .await
         .expect("Failed to initialize Drive");
 
@@ -226,12 +421,30 @@ async fn main() -> std::io::Result<()> {
         config.server.host, config.server.port
     );
 
-    let worker_count = std::thread::available_parallelism()
+    .unwrap_or(4);
+let worker_count = std::thread::available_parallelism()
+.map(|n| n.get())
+.unwrap_or(4);
+trace!("Configured worker threads: {}", worker_count);
+.map(|n| n.get())
+.unwrap_or(4);
+let worker_count = std::thread::available_parallelism()
+.map(|n| n.get())
+.unwrap_or(4);
+trace!("Configured worker threads: {}", worker_count);
+.unwrap_or(4);
+let worker_count = std::thread::available_parallelism()
+.map(|n| n.get())
+.unwrap_or(4);
+trace!("Configured worker threads: {}", worker_count);
         .map(|n| n.get())
         .unwrap_or(4);
 
     // Spawn AutomationService in a LocalSet on a separate thread
-    let automation_state = app_state.clone();
+    std::thread::spawn(move || {
+let automation_state = app_state.clone();
+trace!("Spawning automation service thread");
+std::thread::spawn(move || {
     std::thread::spawn(move || {
         let rt = tokio::runtime::Builder::new_current_thread()
             .enable_all()
@@ -254,6 +467,15 @@ async fn main() -> std::io::Result<()> {
     let _drive_handle = drive_monitor.spawn();
 
     HttpServer::new(move || {
+trace!("Creating new HTTP server instance");
+let cors = Cors::default()
+let cors = Cors::default()
+HttpServer::new(move || {
+trace!("Creating new HTTP server instance");
+let cors = Cors::default()
+HttpServer::new(move || {
+trace!("Creating new HTTP server instance");
+let cors = Cors::default()
         let cors = Cors::default()
             .allow_any_origin()
             .allow_any_method()

src/shared/config.rs

@@ -0,0 +1,65 @@
+pub database: DatabaseConfig,
+pub drive: DriveConfig,
+pub meet: MeetConfig,
+}
+
+pub struct DatabaseConfig {
+pub url: String,
+pub max_connections: u32,
+}
+
+pub struct DriveConfig {
+pub storage_path: String,
+}
+
+pub struct MeetConfig {
+pub api_key: String,
+pub api_secret: String,
+}
+use serde::Deserialize;
+use dotenvy::dotenv;
+use std::env;
+
+#[derive(Debug, Deserialize)]
+pub struct AppConfig {
+pub database: DatabaseConfig,
+pub drive: DriveConfig,
+pub meet: MeetConfig,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DatabaseConfig {
+pub url: String,
+pub max_connections: u32,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DriveConfig {
+pub storage_path: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct MeetConfig {
+pub api_key: String,
+pub api_secret: String,
+}
+
+impl AppConfig {
+pub fn load() -> anyhow::Result<Self> {
+dotenv().ok();
+
+Ok(Self {
+database: DatabaseConfig {
+url: env::var("DATABASE_URL")?,
+max_connections: env::var("DATABASE_MAX_CONNECTIONS")?.parse()?,
+},
+drive: DriveConfig {
+storage_path: env::var("DRIVE_STORAGE_PATH")?,
+},
+meet: MeetConfig {
+api_key: env::var("MEET_API_KEY")?,
+api_secret: env::var("MEET_API_SECRET")?,
+},
+})
+}
+}