GeneralBots/botserver
2
1
Fork 0
Code Issues Pull requests Projects Releases 323 Packages Wiki Activity Actions

Refactor bootstrap and package manager, add ureq

Browse source 
- Split package manager into separate modules
- Expose only the installer API
- Simplify BootstrapManager to install components and load config
- Pin ureq to 3.1.2 and add ureq‑proto crate
- Clean up configuration code and remove legacy comments
- Update helper scripts and server start command formatting
This commit is contained in:
Rodrigo Rodriguez (Pragmatismo) 2025-10-19 11:08:23 -03:00
parent e1f9111392
commit aa69c63cee
11 changed files with 175 additions and 2021 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
Cargo.lock generated
View file

@ -509,7 +509,7 @@ dependencies = [
"quote",
"serde",
"serde_json",
"ureq",
"ureq 2.12.1",
]
[[package]]
@ -1056,6 +1056,7 @@ dependencies = [
"tokio-stream",
"tracing",
"tracing-subscriber",
"ureq 3.1.2",
"urlencoding",
"uuid",
"zip 2.4.2",
@ -5658,6 +5659,36 @@ dependencies = [
"webpki-roots 0.26.11",
]
[[package]]
name = "ureq"
version = "3.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99ba1025f18a4a3fc3e9b48c868e9beb4f24f4b4b1a325bada26bd4119f46537"
dependencies = [
"base64 0.22.1",
"flate2",
"log",
"percent-encoding",
"rustls 0.23.32",
"rustls-pemfile 2.2.0",
"rustls-pki-types",
"ureq-proto",
"utf-8",
"webpki-roots 1.0.3",
]
[[package]]
name = "ureq-proto"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60b4531c118335662134346048ddb0e54cc86bd7e81866757873055f0e38f5d2"
dependencies = [
"base64 0.22.1",
"http 1.3.1",
"httparse",
"log",
]
[[package]]
name = "url"
version = "2.5.7"

1
Cargo.toml
View file

@ -92,3 +92,4 @@ rand = "0.9.2"
pdf-extract = "0.10.0"
scraper = "0.20"
sha2 = "0.10.9"
ureq = "3.1.2"

1
add-req.sh
View file

@ -4,7 +4,6 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$SCRIPT_DIR"
OUTPUT_FILE="/tmp/prompt.out"
rm -f "$OUTPUT_FILE"
echo "Consolidated LLM Context" > "$OUTPUT_FILE"
prompts=(

13
fix-errors.sh
View file

@ -3,13 +3,13 @@
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$SCRIPT_DIR"
OUTPUT_FILE="/tmp/prompt.out"
rm $OUTPUT_FILE
echo "Please, fix this consolidated LLM Context" > "$OUTPUT_FILE"
prompts=(
"./prompts/dev/platform/fix-errors.md"
"./prompts/dev/platform/shared.md"
"./Cargo.toml"
"./prompts/dev/platform/fix-errors.md"
)
for file in "${prompts[@]}"; do
@ -22,17 +22,18 @@ dirs=(
#"automation"
#"basic"
#"bot"
"bootstrap"
#"bootstrap"
#"channels"
#"config"
"config"
#"context"
#"email"
#"file"
#"llm"
#"llm_legacy"
#"org"
"session"
"shared"
"package_manager"
#"session"
#"shared"
#"tests"
#"tools"
#"web_automation"

5
gbot.sh
View file

@ -1,2 +1,3 @@
clear && cargo build && sudo RUST_BACKTRACE=1 ./target/debug/botserver
clear && \
cargo build && \
sudo RUST_BACKTRACE=1 ./target/debug/botserver install tables

23
prompts/dev/platform/fix-errors.md
View file

@ -10,26 +10,3 @@ If something, need to be added to a external file, inform it separated.
3. **Respect Cargo.toml** - Check dependencies, editions, and features to avoid compiler errors
4. **Type safety** - Ensure all types match and trait bounds are satisfied
5. **Ownership rules** - Fix borrowing, ownership, and lifetime issues
MORE RULES:
- Return only the modified files as a single `.sh` script using `cat`, so the - code can be restored directly.
- You MUST return exactly this example format:
```sh
#!/bin/bash
# Restore fixed Rust project
cat > src/<filenamehere>.rs << 'EOF'
use std::io;
// test
cat > src/<anotherfile>.rs << 'EOF'
// Fixed library code
pub fn add(a: i32, b: i32) -> i32 {
a + b
}
EOF
----

1
prompts/dev/platform/shared.md
View file

@ -2,6 +2,7 @@ MOST IMPORTANT CODE GENERATION RULES:
- No placeholders, never comment/uncomment code, no explanations, no filler text.
- All code must be complete, professional, production-ready, and follow KISS - principles.
- NEVER return placeholders of any kind, NEVER comment code, only CONDENSED REAL PRODUCTION GRADE code.
- REMOTE ALL COMMENTS FROM GENERATED CODE. DO NOT COMMENT AT ALL, NO TALK!
- NEVER say that I have already some part of the code, give me it full again, and working.
- Always increment logging with (all-in-one-line) info!, debug!, trace! to give birth to the console.
- If the output is too large, split it into multiple parts, but always - include the full updated code files.

506
src/bootstrap/mod.rs
View file

@ -1,500 +1,58 @@
use crate::config::AppConfig;
use crate::package_manager::{InstallMode, PackageManager};
use anyhow::{Context, Result};
use diesel::prelude::*;
use log::{info, warn};
use std::collections::HashMap;
use std::net::TcpListener;
use std::path::PathBuf;
use std::process::Command;
use std::thread;
use std::time::Duration;
use anyhow::Result;
use log::{debug, info, trace, warn};
pub struct BootstrapManager {
mode: InstallMode,
tenant: String,
base_path: PathBuf,
config_values: HashMap<String, String>,
pub install_mode: InstallMode,
pub tenant: Option<String>,
}
impl BootstrapManager {
pub fn new(mode: InstallMode, tenant: Option<String>) -> Self {
let tenant = tenant.unwrap_or_else(|| "default".to_string());
let base_path = if mode == InstallMode::Container {
PathBuf::from("/opt/gbo")
} else {
PathBuf::from("./botserver-stack")
};
pub fn new(install_mode: InstallMode, tenant: Option<String>) -> Self {
info!(
"Initializing BootstrapManager with mode {:?} and tenant {:?}",
install_mode, tenant
);
Self {
mode,
install_mode,
tenant,
base_path,
config_values: HashMap::new(),
}
}
pub fn bootstrap(&mut self) -> Result<AppConfig> {
info!(
"Starting bootstrap process in {:?} mode for tenant {}",
self.mode, self.tenant
);
info!("Starting bootstrap process");
std::fs::create_dir_all(&self.base_path).context("Failed to create base directory")?;
let pm = PackageManager::new(self.install_mode.clone(), self.tenant.clone())?;
let pm = PackageManager::new(self.mode.clone(), Some(self.tenant.clone()))?;
let required_components = vec!["drive", "cache", "tables", "llm"];
info!("Installing core infrastructure components");
self.install_and_configure_tables(&pm)?;
self.install_and_configure_drive(&pm)?;
self.install_and_configure_cache(&pm)?;
self.install_and_configure_llm(&pm)?;
info!("Creating database schema and storing configuration");
let config = self.build_config()?;
self.initialize_database(&config)?;
self.store_configuration_in_db(&config)?;
for component in required_components {
if !pm.is_installed(component) {
info!("Installing required component: {}", component);
futures::executor::block_on(pm.install(component))?;
trace!("Successfully installed component: {}", component);
} else {
debug!("Component {} already installed", component);
}
}
info!("Bootstrap completed successfully");
Ok(config)
}
fn install_and_configure_tables(&mut self, pm: &PackageManager) -> Result<()> {
info!("Installing PostgreSQL tables component");
pm.install("tables")?;
let tables_port = self.find_available_port(5432);
let tables_password = self.generate_password();
self.config_values
.insert("TABLES_USERNAME".to_string(), self.tenant.clone());
self.config_values
.insert("TABLES_PASSWORD".to_string(), tables_password.clone());
self.config_values
.insert("TABLES_SERVER".to_string(), self.get_service_host("tables"));
self.config_values
.insert("TABLES_PORT".to_string(), tables_port.to_string());
self.config_values
.insert("TABLES_DATABASE".to_string(), format!("{}_db", self.tenant));
self.wait_for_service(&self.get_service_host("tables"), tables_port, 30)?;
info!(
"PostgreSQL configured: {}:{}",
self.get_service_host("tables"),
tables_port
);
Ok(())
}
fn install_and_configure_drive(&mut self, pm: &PackageManager) -> Result<()> {
info!("Installing MinIO drive component");
pm.install("drive")?;
let drive_port = self.find_available_port(9000);
let _drive_console_port = self.find_available_port(9001);
let drive_user = "minioadmin".to_string();
let drive_password = self.generate_password();
self.config_values.insert(
"DRIVE_SERVER".to_string(),
format!("{}:{}", self.get_service_host("drive"), drive_port),
);
self.config_values
.insert("DRIVE_ACCESSKEY".to_string(), drive_user.clone());
self.config_values
.insert("DRIVE_SECRET".to_string(), drive_password.clone());
self.config_values
.insert("DRIVE_USE_SSL".to_string(), "false".to_string());
self.config_values
.insert("DRIVE_ORG_PREFIX".to_string(), self.tenant.clone());
self.config_values.insert(
"DRIVE_BUCKET".to_string(),
format!("{}default.gbai", self.tenant),
);
self.wait_for_service(&self.get_service_host("drive"), drive_port, 30)?;
info!(
"MinIO configured: {}:{}",
self.get_service_host("drive"),
drive_port
);
Ok(())
}
fn install_and_configure_cache(&mut self, pm: &PackageManager) -> Result<()> {
info!("Installing Redis cache component");
pm.install("cache")?;
let cache_port = self.find_available_port(6379);
self.config_values.insert(
"CACHE_URL".to_string(),
format!("redis://{}:{}/", self.get_service_host("cache"), cache_port),
);
self.wait_for_service(&self.get_service_host("cache"), cache_port, 30)?;
info!(
"Redis configured: {}:{}",
self.get_service_host("cache"),
cache_port
);
Ok(())
}
fn install_and_configure_llm(&mut self, pm: &PackageManager) -> Result<()> {
info!("Installing LLM server component");
pm.install("llm")?;
let llm_port = self.find_available_port(8081);
self.config_values.insert(
"LLM_URL".to_string(),
format!("http://{}:{}", self.get_service_host("llm"), llm_port),
);
self.config_values.insert(
"AI_ENDPOINT".to_string(),
format!("http://{}:{}", self.get_service_host("llm"), llm_port),
);
self.config_values
.insert("AI_KEY".to_string(), "empty".to_string());
self.config_values
.insert("AI_INSTANCE".to_string(), "llama-local".to_string());
self.config_values
.insert("AI_VERSION".to_string(), "1.0".to_string());
self.wait_for_service(&self.get_service_host("llm"), llm_port, 60)?;
info!(
"LLM server configured: {}:{}",
self.get_service_host("llm"),
llm_port
);
Ok(())
}
fn build_config(&self) -> Result<AppConfig> {
info!("Building application configuration from discovered services");
let get_str = |key: &str, default: &str| -> String {
self.config_values
.get(key)
.cloned()
.unwrap_or_else(|| default.to_string())
};
let get_u32 = |key: &str, default: u32| -> u32 {
self.config_values
.get(key)
.and_then(|v| v.parse().ok())
.unwrap_or(default)
};
let get_u16 = |key: &str, default: u16| -> u16 {
self.config_values
.get(key)
.and_then(|v| v.parse().ok())
.unwrap_or(default)
};
let get_bool = |key: &str, default: bool| -> bool {
self.config_values
.get(key)
.map(|v| v.to_lowercase() == "true")
.unwrap_or(default)
};
let stack_path = self.base_path.clone();
let database = crate::config::DatabaseConfig {
username: get_str("TABLES_USERNAME", "botserver"),
password: get_str("TABLES_PASSWORD", "botserver"),
server: get_str("TABLES_SERVER", "localhost"),
port: get_u32("TABLES_PORT", 5432),
database: get_str("TABLES_DATABASE", "botserver_db"),
};
let database_custom = database.clone();
let minio = crate::config::DriveConfig {
server: get_str("DRIVE_SERVER", "localhost:9000"),
access_key: get_str("DRIVE_ACCESSKEY", "minioadmin"),
secret_key: get_str("DRIVE_SECRET", "minioadmin"),
use_ssl: get_bool("DRIVE_USE_SSL", false),
org_prefix: get_str("DRIVE_ORG_PREFIX", "botserver"),
};
let email = crate::config::EmailConfig {
from: get_str("EMAIL_FROM", "noreply@example.com"),
server: get_str("EMAIL_SERVER", "smtp.example.com"),
port: get_u16("EMAIL_PORT", 587),
username: get_str("EMAIL_USER", "user"),
password: get_str("EMAIL_PASS", "pass"),
};
let ai = crate::config::AIConfig {
instance: get_str("AI_INSTANCE", "llama-local"),
key: get_str("AI_KEY", "empty"),
version: get_str("AI_VERSION", "1.0"),
endpoint: get_str("AI_ENDPOINT", "http://localhost:8081"),
};
let server_host = if self.mode == InstallMode::Container {
"0.0.0.0".to_string()
} else {
"127.0.0.1".to_string()
};
Ok(AppConfig {
minio,
server: crate::config::ServerConfig {
host: server_host,
port: self.find_available_port(8080),
},
database,
database_custom,
email,
ai,
s3_bucket: get_str("DRIVE_BUCKET", "default.gbai"),
site_path: format!("{}/sites", stack_path.display()),
stack_path,
db_conn: None,
})
}
fn initialize_database(&self, config: &AppConfig) -> Result<()> {
use diesel::pg::PgConnection;
info!("Initializing database schema at {}", config.database_url());
// Attempt to establish a PostgreSQL connection with retries.
let mut retries = 5;
let mut conn = loop {
match PgConnection::establish(&config.database_url()) {
Ok(c) => break c,
Err(e) if retries > 0 => {
warn!("Database connection failed, retrying in 2s: {}", e);
thread::sleep(Duration::from_secs(2));
retries -= 1;
let config = match diesel::Connection::establish(
"postgres://botserver:botserver@localhost:5432/botserver",
) {
Ok(mut conn) => {
trace!("Connected to database for config loading");
AppConfig::from_database(&mut conn)
}
Err(e) => {
return Err(anyhow::anyhow!(
"Failed to connect to database after retries: {}",
e
))
}
warn!("Failed to connect to database for config: {}", e);
trace!("Falling back to environment configuration");
AppConfig::from_env()
}
};
// Create the server_configuration table.
diesel::sql_query(
"CREATE TABLE IF NOT EXISTS server_configuration (
id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
config_key TEXT NOT NULL UNIQUE,
config_value TEXT NOT NULL,
config_type TEXT NOT NULL DEFAULT 'string',
is_encrypted BOOLEAN NOT NULL DEFAULT false,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)",
)
.execute(&mut conn)
.context("Failed to create server_configuration table")?;
// Create the bot_configuration table.
diesel::sql_query(
"CREATE TABLE IF NOT EXISTS bot_configuration (
id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
bot_id UUID NOT NULL,
config_key TEXT NOT NULL,
config_value TEXT NOT NULL,
config_type TEXT NOT NULL DEFAULT 'string',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
UNIQUE(bot_id, config_key)
)",
)
.execute(&mut conn)
.context("Failed to create bot_configuration table")?;
// Create the gbot_config_sync table.
diesel::sql_query(
"CREATE TABLE IF NOT EXISTS gbot_config_sync (
id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
bot_id UUID NOT NULL UNIQUE,
config_file_path TEXT NOT NULL,
file_hash TEXT NOT NULL,
last_sync_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
sync_count INTEGER NOT NULL DEFAULT 0
)",
)
.execute(&mut conn)
.context("Failed to create gbot_config_sync table")?;
info!("Database schema initialized successfully");
Ok(())
}
fn store_configuration_in_db(&self, config: &AppConfig) -> Result<()> {
use diesel::pg::PgConnection;
info!("Storing configuration in database");
// Establish a PostgreSQL connection explicitly.
let mut conn = PgConnection::establish(&config.database_url())
.context("Failed to establish database connection for storing configuration")?;
// Store dynamic configuration values.
for (key, value) in &self.config_values {
diesel::sql_query(
"INSERT INTO server_configuration (config_key, config_value, config_type)
VALUES ($1, $2, 'string')
ON CONFLICT (config_key)
DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()",
)
.bind::<diesel::sql_types::Text, _>(key)
.bind::<diesel::sql_types::Text, _>(value)
.execute(&mut conn)
.with_context(|| format!("Failed to store config key: {}", key))?;
}
// Store static configuration entries.
diesel::sql_query(
"INSERT INTO server_configuration (config_key, config_value, config_type)
VALUES ('SERVER_HOST', $1, 'string')
ON CONFLICT (config_key)
DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()",
)
.bind::<diesel::sql_types::Text, _>(&config.server.host)
.execute(&mut conn)
.context("Failed to store SERVER_HOST")?;
diesel::sql_query(
"INSERT INTO server_configuration (config_key, config_value, config_type)
VALUES ('SERVER_PORT', $1, 'string')
ON CONFLICT (config_key)
DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()",
)
.bind::<diesel::sql_types::Text, _>(&config.server.port.to_string())
.execute(&mut conn)
.context("Failed to store SERVER_PORT")?;
diesel::sql_query(
"INSERT INTO server_configuration (config_key, config_value, config_type)
VALUES ('STACK_PATH', $1, 'string')
ON CONFLICT (config_key)
DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()",
)
.bind::<diesel::sql_types::Text, _>(&config.stack_path.display().to_string())
.execute(&mut conn)
.context("Failed to store STACK_PATH")?;
diesel::sql_query(
"INSERT INTO server_configuration (config_key, config_value, config_type)
VALUES ('SITES_ROOT', $1, 'string')
ON CONFLICT (config_key)
DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()",
)
.bind::<diesel::sql_types::Text, _>(&config.site_path)
.execute(&mut conn)
.context("Failed to store SITES_ROOT")?;
info!(
"Configuration stored in database successfully with {} entries",
self.config_values.len() + 4
);
Ok(())
}
fn find_available_port(&self, preferred: u16) -> u16 {
if self.mode == InstallMode::Container {
return preferred;
}
for port in preferred..preferred + 100 {
if TcpListener::bind(("127.0.0.1", port)).is_ok() {
return port;
}
}
preferred
}
fn generate_password(&self) -> String {
use rand::Rng;
const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
let mut rng = rand::rng();
(0..16)
.map(|_| {
let idx = rng.random_range(0..CHARSET.len());
CHARSET[idx] as char
})
.collect()
}
fn get_service_host(&self, component: &str) -> String {
match self.mode {
InstallMode::Container => {
let container_name = format!("{}-{}", self.tenant, component);
self.get_container_ip(&container_name)
.unwrap_or_else(|_| "127.0.0.1".to_string())
}
InstallMode::Local => "127.0.0.1".to_string(),
}
}
fn get_container_ip(&self, container_name: &str) -> Result<String> {
let output = Command::new("lxc")
.args(&["list", container_name, "--format=json"])
.output()?;
if !output.status.success() {
return Err(anyhow::anyhow!("Failed to get container info"));
}
let json: serde_json::Value = serde_json::from_slice(&output.stdout)?;
if let Some(ip) = json
.get(0)
.and_then(|c| c.get("state"))
.and_then(|s| s.get("network"))
.and_then(|n| n.get("eth0"))
.and_then(|e| e.get("addresses"))
.and_then(|a| a.get(0))
.and_then(|a| a.get("address"))
.and_then(|a| a.as_str())
{
Ok(ip.to_string())
} else {
Err(anyhow::anyhow!("Could not extract container IP"))
}
}
fn wait_for_service(&self, host: &str, port: u16, timeout_secs: u64) -> Result<()> {
info!(
"Waiting for service at {}:{} (timeout: {}s)",
host, port, timeout_secs
);
let start = std::time::Instant::now();
while start.elapsed().as_secs() < timeout_secs {
match TcpListener::bind((host, port)) {
Ok(_) => {
thread::sleep(Duration::from_secs(1));
}
Err(_) => {
info!("Service {}:{} is ready", host, port);
return Ok(());
}
}
thread::sleep(Duration::from_secs(1));
}
Err(anyhow::anyhow!(
"Timeout waiting for service at {}:{}",
host,
port
))
Ok(config)
}
}

50
src/config/mod.rs
View file

@ -6,7 +6,6 @@ use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
/// Application configuration - reads from database instead of .env
#[derive(Clone)]
pub struct AppConfig {
pub minio: DriveConfig,
@ -18,7 +17,7 @@ pub struct AppConfig {
pub site_path: String,
pub s3_bucket: String,
pub stack_path: PathBuf,
pub(crate) db_conn: Option<Arc<Mutex<PgConnection>>>,
pub db_conn: Option<Arc<Mutex<PgConnection>>>,
}
#[derive(Clone)]
@ -99,55 +98,40 @@ impl AppConfig {
)
}
/// Get stack path for a specific component
pub fn component_path(&self, component: &str) -> PathBuf {
self.stack_path.join(component)
}
/// Get binary path for a component
pub fn bin_path(&self, component: &str) -> PathBuf {
self.stack_path.join("bin").join(component)
}
/// Get data path for a component
pub fn data_path(&self, component: &str) -> PathBuf {
self.stack_path.join("data").join(component)
}
/// Get config path for a component
pub fn config_path(&self, component: &str) -> PathBuf {
self.stack_path.join("conf").join(component)
}
/// Get log path for a component
pub fn log_path(&self, component: &str) -> PathBuf {
self.stack_path.join("logs").join(component)
}
/// Load configuration from database
/// Falls back to defaults if database is not yet initialized
pub fn from_database(conn: &mut PgConnection) -> Self {
info!("Loading configuration from database...");
info!("Loading configuration from database");
// Load all configuration from database
let config_map = match Self::load_config_from_db(conn) {
Ok(map) => {
info!(
"Successfully loaded {} config values from database",
map.len()
);
info!("Loaded {} config values from database", map.len());
map
}
Err(e) => {
warn!(
"Failed to load config from database: {}. Using defaults.",
e
);
warn!("Failed to load config from database: {}. Using defaults", e);
HashMap::new()
}
};
// Helper to get config value with fallback
let get_str = |key: &str, default: &str| -> String {
config_map
.get(key)
@ -234,10 +218,8 @@ impl AppConfig {
}
}
/// Legacy method - reads from .env for backward compatibility
/// Will be deprecated once database setup is complete
pub fn from_env() -> Self {
warn!("Loading configuration from environment variables (legacy mode)");
warn!("Loading configuration from environment variables");
let stack_path =
std::env::var("STACK_PATH").unwrap_or_else(|_| "./botserver-stack".to_string());
@ -319,11 +301,9 @@ impl AppConfig {
}
}
/// Load all configuration from database into a HashMap
fn load_config_from_db(
conn: &mut PgConnection,
) -> Result<HashMap<String, ServerConfigRow>, diesel::result::Error> {
// Try to query the server_configuration table
let results = diesel::sql_query(
"SELECT id, config_key, config_value, config_type, is_encrypted
FROM server_configuration",
@ -338,7 +318,6 @@ impl AppConfig {
Ok(map)
}
/// Update a configuration value in the database
pub fn set_config(
&self,
conn: &mut PgConnection,
@ -354,24 +333,20 @@ impl AppConfig {
Ok(())
}
/// Get a configuration value from the database
pub fn get_config(
&self,
conn: &mut PgConnection,
key: &str,
fallback: Option<&str>,
) -> Result<String, diesel::result::Error> {
// Use empty string when no fallback is supplied
let fallback_str = fallback.unwrap_or("");
// Define a temporary struct that matches the shape of the query result.
#[derive(Debug, QueryableByName)]
struct ConfigValue {
#[diesel(sql_type = Text)]
value: String,
}
// Execute the query and map the resulting row to the inner string.
let result = diesel::sql_query("SELECT get_config($1, $2) as value")
.bind::<Text, _>(key)
.bind::<Text, _>(fallback_str)
@ -382,7 +357,6 @@ impl AppConfig {
}
}
/// Configuration manager for handling .gbot/config.csv files
pub struct ConfigManager {
conn: Arc<Mutex<PgConnection>>,
}
@ -392,21 +366,17 @@ impl ConfigManager {
Self { conn }
}
/// Watch and sync .gbot/config.csv file for a bot
pub fn sync_gbot_config(
&self,
bot_id: &uuid::Uuid,
config_path: &str,
) -> Result<usize, String> {
// Import necessary crates for hashing and file handling
use sha2::{Digest, Sha256};
use std::fs;
// Read the config.csv file
let content = fs::read_to_string(config_path)
.map_err(|e| format!("Failed to read config file: {}", e))?;
// Calculate file hash
let mut hasher = Sha256::new();
hasher.update(content.as_bytes());
let file_hash = format!("{:x}", hasher.finalize());
@ -416,7 +386,6 @@ impl ConfigManager {
.lock()
.map_err(|e| format!("Failed to acquire lock: {}", e))?;
// Check if file has changed
#[derive(QueryableByName)]
struct SyncHash {
#[diesel(sql_type = Text)]
@ -436,16 +405,13 @@ impl ConfigManager {
return Ok(0);
}
// Parse CSV and update bot configuration
let mut updated = 0;
for line in content.lines().skip(1) {
// Skip header
let parts: Vec<&str> = line.split(',').collect();
if parts.len() >= 2 {
let key = parts[0].trim();
let value = parts[1].trim();
// Insert or update bot configuration
diesel::sql_query(
"INSERT INTO bot_configuration (id, bot_id, config_key, config_value, config_type)
VALUES (gen_random_uuid()::text, $1, $2, $3, 'string')
@ -462,7 +428,6 @@ impl ConfigManager {
}
}
// Update sync record
diesel::sql_query(
"INSERT INTO gbot_config_sync (id, bot_id, config_file_path, file_hash, sync_count)
VALUES (gen_random_uuid()::text, $1, $2, $3, 1)
@ -476,10 +441,7 @@ impl ConfigManager {
.execute(&mut *conn)
.map_err(|e| format!("Failed to update sync record: {}", e))?;
info!(
"Synced {} config values for bot {} from {}",
updated, bot_id, config_path
);
info!("Synced {} config values for bot {} from {}", updated, bot_id, config_path);
Ok(updated)
}
}

96
src/main.rs
View file

@ -35,15 +35,19 @@ mod whatsapp;
use crate::auth::auth_handler;
use crate::automation::AutomationService;
use crate::bot::{start_session, websocket_handler};
use crate::bootstrap::BootstrapManager;
use crate::bot::{start_session, websocket_handler};
use crate::channels::{VoiceAdapter, WebChannelAdapter};
use crate::config::AppConfig;
use crate::drive_monitor::DriveMonitor;
#[cfg(feature = "email")]
use crate::email::{get_emails, get_latest_email_from, list_emails, save_click, save_draft, send_email};
use crate::email::{
get_emails, get_latest_email_from, list_emails, save_click, save_draft, send_email,
};
use crate::file::{init_drive, upload_file};
use crate::llm_legacy::llm_local::{chat_completions_local, embeddings_local, ensure_llama_servers_running};
use crate::llm_legacy::llm_local::{
chat_completions_local, embeddings_local, ensure_llama_servers_running,
};
use crate::meet::{voice_start, voice_stop};
use crate::package_manager::InstallMode;
use crate::session::{create_session, get_session_history, get_sessions};
@ -60,18 +64,24 @@ async fn main() -> std::io::Result<()> {
let command = &args[1];
match command.as_str() {
"install" | "remove" | "list" | "status" | "--help" | "-h" => {
match package_manager::cli::run() {
match package_manager::cli::run().await {
Ok(_) => return Ok(()),
Err(e) => {
eprintln!("CLI error: {}", e);
return Err(std::io::Error::new(std::io::ErrorKind::Other, format!("CLI command failed: {}", 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)));
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
format!("Unknown command: {}", command),
));
}
}
}
@ -102,7 +112,8 @@ async fn main() -> std::io::Result<()> {
Err(e) => {
log::error!("Bootstrap failed: {}", e);
info!("Attempting to load configuration from database");
match diesel::Connection::establish(&format!("postgres://localhost:5432/botserver_db")) {
match diesel::Connection::establish(&format!("postgres://localhost:5432/botserver_db"))
{
Ok(mut conn) => AppConfig::from_database(&mut conn),
Err(_) => {
info!("Database not available, using environment variables as fallback");
@ -119,16 +130,25 @@ async fn main() -> std::io::Result<()> {
Ok(conn) => Arc::new(Mutex::new(conn)),
Err(e) => {
log::error!("Failed to connect to main database: {}", e);
return Err(std::io::Error::new(std::io::ErrorKind::ConnectionRefused, format!("Database connection failed: {}", e)));
return Err(std::io::Error::new(
std::io::ErrorKind::ConnectionRefused,
format!("Database connection failed: {}", e),
));
}
};
let db_custom_pool = db_pool.clone();
info!("Initializing LLM server at {}", cfg.ai.endpoint);
ensure_llama_servers_running().await.expect("Failed to initialize LLM local server");
ensure_llama_servers_running()
.await
.expect("Failed to initialize LLM local server");
let cache_url = cfg.config_path("cache").join("redis.conf").display().to_string();
let cache_url = cfg
.config_path("cache")
.join("redis.conf")
.display()
.to_string();
let redis_client = match redis::Client::open(cache_url.as_str()) {
Ok(client) => Some(Arc::new(client)),
Err(e) => {
@ -138,18 +158,37 @@ async fn main() -> std::io::Result<()> {
};
let tool_manager = Arc::new(tools::ToolManager::new());
let llm_provider = Arc::new(crate::llm::OpenAIClient::new("empty".to_string(), Some(cfg.ai.endpoint.clone())));
let llm_provider = Arc::new(crate::llm::OpenAIClient::new(
"empty".to_string(),
Some(cfg.ai.endpoint.clone()),
));
let web_adapter = Arc::new(WebChannelAdapter::new());
let voice_adapter = Arc::new(VoiceAdapter::new("https://livekit.example.com".to_string(), "api_key".to_string(), "api_secret".to_string()));
let whatsapp_adapter = Arc::new(WhatsAppAdapter::new("whatsapp_token".to_string(), "phone_number_id".to_string(), "verify_token".to_string()));
let voice_adapter = Arc::new(VoiceAdapter::new(
"https://livekit.example.com".to_string(),
"api_key".to_string(),
"api_secret".to_string(),
));
let whatsapp_adapter = Arc::new(WhatsAppAdapter::new(
"whatsapp_token".to_string(),
"phone_number_id".to_string(),
"verify_token".to_string(),
));
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");
let session_manager = Arc::new(tokio::sync::Mutex::new(session::SessionManager::new(diesel::Connection::establish(&cfg.database_url()).unwrap(), redis_client.clone())));
let auth_service = Arc::new(tokio::sync::Mutex::new(auth::AuthService::new(diesel::Connection::establish(&cfg.database_url()).unwrap(), redis_client.clone())));
let session_manager = Arc::new(tokio::sync::Mutex::new(session::SessionManager::new(
diesel::Connection::establish(&cfg.database_url()).unwrap(),
redis_client.clone(),
)));
let auth_service = Arc::new(tokio::sync::Mutex::new(auth::AuthService::new(
diesel::Connection::establish(&cfg.database_url()).unwrap(),
redis_client.clone(),
)));
let app_state = Arc::new(AppState {
s3_client: Some(drive.clone()),
@ -163,7 +202,10 @@ async fn main() -> std::io::Result<()> {
auth_service: auth_service.clone(),
channels: Arc::new(Mutex::new({
let mut map = HashMap::new();
map.insert("web".to_string(), web_adapter.clone() as Arc<dyn crate::channels::ChannelAdapter>);
map.insert(
"web".to_string(),
web_adapter.clone() as Arc<dyn crate::channels::ChannelAdapter>,
);
map
})),
response_channels: Arc::new(tokio::sync::Mutex::new(HashMap::new())),
@ -173,12 +215,20 @@ async fn main() -> std::io::Result<()> {
tool_api: tool_api.clone(),
});
info!("Starting HTTP server on {}:{}", config.server.host, config.server.port);
info!(
"Starting HTTP server on {}:{}",
config.server.host, config.server.port
);
let worker_count = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(4);
let worker_count = std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(4);
let automation_state = app_state.clone();
let automation = AutomationService::new(automation_state, "templates/announcements.gbai/announcements.gbdialog");
let automation = AutomationService::new(
automation_state,
"templates/announcements.gbai/announcements.gbdialog",
);
let _automation_handle = automation.spawn();
let drive_state = app_state.clone();
@ -187,7 +237,11 @@ async fn main() -> std::io::Result<()> {
let _drive_handle = drive_monitor.spawn();
HttpServer::new(move || {
let cors = Cors::default().allow_any_origin().allow_any_method().allow_any_header().max_age(3600);
let cors = Cors::default()
.allow_any_origin()
.allow_any_method()
.allow_any_header()
.max_age(3600);
let app_state_clone = app_state.clone();
let mut app = App::new()

1445
src/package_manager/mod.rs
View file

File diff suppressed because it is too large Load diff