Add initial llm-bridge project

src/config.rs

@@ -0,0 +1,562 @@
+//! Global configuration: TOML file, defaults and CLI overrides.
+
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::error::{GatewayError, Result};
+use crate::paths::{self, Layout};
+
+/// When to save screenshots and DOM dumps for debugging.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ScreenshotMode {
+    Never,
+    #[default]
+    OnError,
+    Always,
+}
+
+/// How a thread is continued on the provider web UI.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ConversationStrategy {
+    #[default]
+    Auto,
+    Reuse,
+    Replay,
+}
+
+/// Where the client conversation id comes from.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ConversationIdSource {
+    #[default]
+    Fingerprint,
+    Header,
+    Uuid,
+}
+
+/// How much the browser hides the fact that it is automated.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum StealthMode {
+    /// Leave the page alone. Chromium is launched with a switch that already
+    /// hides navigator.webdriver and the user agent stays genuine, which is
+    /// what sign-in providers such as Google expect.
+    #[default]
+    Off,
+    /// Also patch navigator.webdriver from an injected script.
+    Minimal,
+    /// Full chromiumoxide stealth, including a spoofed user agent.
+    ///
+    /// Warning: it advertises an outdated Chrome version, which is itself a
+    /// bot signal and makes OAuth providers refuse the sign-in.
+    Aggressive,
+}
+
+impl StealthMode {
+    /// Parse the --stealth flag.
+    pub fn parse(raw: &str) -> Result<Self> {
+        match raw.trim().to_lowercase().as_str() {
+            "off" | "none" => Ok(Self::Off),
+            "minimal" | "light" => Ok(Self::Minimal),
+            "aggressive" | "full" => Ok(Self::Aggressive),
+            other => Err(GatewayError::Config(format!(
+                "unknown stealth mode '{other}', expected off, minimal or aggressive"
+            ))),
+        }
+    }
+}
+
+/// How the prompt text is pushed into the web editor.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum InjectMethod {
+    #[default]
+    Auto,
+    InsertText,
+    ExecCommand,
+    TypeStr,
+}
+
+/// Where the final answer text comes from.
+///
+/// A web UI renders its answer as rich HTML, and `innerText` flattens it: code
+/// fences, tables and lists all collapse into plain text. The fidelity pass
+/// runs once, when the answer has settled, and this setting decides how.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum MarkdownMode {
+    /// Clipboard when the provider has a copy button, otherwise the DOM.
+    #[default]
+    Auto,
+    /// Always click the provider copy button and read the clipboard over CDP.
+    /// Falls back to the DOM when the clipboard cannot be read.
+    Clipboard,
+    /// Always convert the answer node's HTML to Markdown.
+    Dom,
+    /// Keep the historical behaviour: the visible text, formatting flattened.
+    Text,
+}
+
+impl MarkdownMode {
+    /// Parse the --markdown flag.
+    pub fn parse(raw: &str) -> Result<Self> {
+        match raw.trim().to_lowercase().as_str() {
+            "auto" => Ok(Self::Auto),
+            "clipboard" | "copy" => Ok(Self::Clipboard),
+            "dom" | "html" => Ok(Self::Dom),
+            "text" | "plain" | "off" => Ok(Self::Text),
+            other => Err(GatewayError::Config(format!(
+                "unknown markdown mode '{other}', expected auto, clipboard, dom or text"
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ServerSection {
+    pub host: String,
+    pub port: u16,
+    pub api_key: String,
+    pub include_warnings: bool,
+    pub request_body_limit: usize,
+}
+
+impl Default for ServerSection {
+    fn default() -> Self {
+        Self {
+            host: "127.0.0.1".to_string(),
+            port: 8080,
+            api_key: String::new(),
+            include_warnings: true,
+            request_body_limit: 32 * 1024 * 1024,
+        }
+    }
+}
+
+impl ServerSection {
+    /// True when the server is reachable from another host.
+    pub fn is_public_bind(&self) -> bool {
+        let host = self.host.trim();
+        !(host == "127.0.0.1" || host == "localhost" || host == "::1")
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct BrowserSection {
+    pub executable: String,
+    pub headless: bool,
+    pub profile_dir: String,
+    /// Concurrent turns allowed per provider account, i.e. tabs kept open.
+    pub max_tabs: usize,
+    /// How long a request waits for a free tab before it is refused with 429.
+    pub busy_wait_s: u64,
+    pub launch_timeout_s: u64,
+    pub request_timeout_s: u64,
+    pub extra_args: Vec<String>,
+    pub stealth: StealthMode,
+    /// Attach to a browser the user started instead of launching one.
+    pub attach: bool,
+    /// Debug port of that browser.
+    pub debug_port: u16,
+}
+
+impl Default for BrowserSection {
+    fn default() -> Self {
+        Self {
+            executable: String::new(),
+            headless: false,
+            profile_dir: String::new(),
+            max_tabs: 1,
+            busy_wait_s: 30,
+            launch_timeout_s: 60,
+            request_timeout_s: 60,
+            extra_args: vec![
+                "--disable-blink-features=AutomationControlled".to_string(),
+                "--no-first-run".to_string(),
+                "--no-default-browser-check".to_string(),
+            ],
+            stealth: StealthMode::Off,
+            attach: false,
+            debug_port: 9222,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ConversationSection {
+    pub store: String,
+    pub strategy: ConversationStrategy,
+    pub id_source: ConversationIdSource,
+}
+
+impl Default for ConversationSection {
+    fn default() -> Self {
+        Self {
+            store: String::new(),
+            strategy: ConversationStrategy::Auto,
+            id_source: ConversationIdSource::Fingerprint,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct CaptureSection {
+    pub poll_interval_ms: u64,
+    pub quiet_ms: u64,
+    pub response_timeout_s: u64,
+    pub inject_method: InjectMethod,
+    /// Fidelity of the captured answer (see `MarkdownMode`).
+    pub markdown: MarkdownMode,
+    /// How long the clipboard read is given before the DOM conversion wins.
+    pub clipboard_timeout_ms: u64,
+    /// Upper bound accepted for the OpenAI `n` parameter.
+    pub max_variants: u32,
+}
+
+impl Default for CaptureSection {
+    fn default() -> Self {
+        Self {
+            poll_interval_ms: 400,
+            quiet_ms: 1500,
+            response_timeout_s: 180,
+            inject_method: InjectMethod::Auto,
+            markdown: MarkdownMode::Auto,
+            clipboard_timeout_ms: 1500,
+            max_variants: 4,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct TokensSection {
+    pub encoding: String,
+    pub fallback_heuristic: bool,
+}
+
+impl Default for TokensSection {
+    fn default() -> Self {
+        Self {
+            encoding: "o200k_base".to_string(),
+            fallback_heuristic: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct DebugSection {
+    pub screenshots: ScreenshotMode,
+    pub dir: String,
+}
+
+impl Default for DebugSection {
+    fn default() -> Self {
+        Self {
+            screenshots: ScreenshotMode::OnError,
+            dir: String::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct LoggingSection {
+    pub level: String,
+    pub format: String,
+    pub file: String,
+}
+
+impl Default for LoggingSection {
+    fn default() -> Self {
+        Self {
+            level: "info".to_string(),
+            format: "pretty".to_string(),
+            file: String::new(),
+        }
+    }
+}
+
+/// Root configuration object.
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct GlobalConfig {
+    pub server: ServerSection,
+    pub browser: BrowserSection,
+    pub conversation: ConversationSection,
+    pub capture: CaptureSection,
+    pub tokens: TokensSection,
+    pub debug: DebugSection,
+    pub logging: LoggingSection,
+}
+
+impl GlobalConfig {
+    /// Read the configuration file, returning defaults when it does not exist.
+    pub fn load(path: &Path) -> Result<Self> {
+        if !path.exists() {
+            return Ok(Self::default());
+        }
+        let raw = std::fs::read_to_string(path)
+            .map_err(|e| GatewayError::Config(format!("reading {}: {e}", path.display())))?;
+        Self::from_toml(&raw)
+    }
+
+    pub fn from_toml(raw: &str) -> Result<Self> {
+        toml::from_str::<Self>(raw).map_err(|e| GatewayError::Config(e.to_string()))
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        if self.server.port == 0 {
+            return Err(GatewayError::Config("server.port must not be 0".into()));
+        }
+        if self.browser.max_tabs == 0 {
+            return Err(GatewayError::Config(
+                "browser.max_tabs must be at least 1".into(),
+            ));
+        }
+        if self.capture.poll_interval_ms < 50 {
+            return Err(GatewayError::Config(
+                "capture.poll_interval_ms must be at least 50".into(),
+            ));
+        }
+        if self.capture.response_timeout_s == 0 {
+            return Err(GatewayError::Config(
+                "capture.response_timeout_s must not be 0".into(),
+            ));
+        }
+        if self.capture.max_variants == 0 {
+            return Err(GatewayError::Config(
+                "capture.max_variants must be at least 1".into(),
+            ));
+        }
+        if self.browser.attach && self.browser.debug_port == 0 {
+            return Err(GatewayError::Config(
+                "browser.debug_port must be set when browser.attach is true".into(),
+            ));
+        }
+        if self.browser.headless && self.server.api_key.is_empty() {
+            // Not fatal: headless mode simply cannot ask the user to log in.
+            tracing::debug!("headless mode cannot prompt for a manual login");
+        }
+        Ok(())
+    }
+
+    pub fn resolved_profile_root(&self, layout: &Layout) -> PathBuf {
+        non_empty_path(&self.browser.profile_dir)
+            .map(|raw| paths::resolve_against(layout.root(), &raw))
+            .unwrap_or_else(|| layout.profiles_dir())
+    }
+
+    pub fn profile_dir_for(&self, layout: &Layout, provider: &str) -> PathBuf {
+        self.resolved_profile_root(layout)
+            .join(provider)
+            .join("user-data-dir")
+    }
+
+    pub fn resolved_debug_dir(&self, layout: &Layout) -> PathBuf {
+        non_empty_path(&self.debug.dir)
+            .map(|raw| paths::resolve_against(layout.root(), &raw))
+            .unwrap_or_else(|| layout.debug_dir())
+    }
+
+    pub fn resolved_store_path(&self, layout: &Layout) -> PathBuf {
+        non_empty_path(&self.conversation.store)
+            .map(|raw| paths::resolve_against(layout.root(), &raw))
+            .unwrap_or_else(|| layout.conversations_file())
+    }
+
+    pub fn resolved_log_file(&self, layout: &Layout) -> PathBuf {
+        non_empty_path(&self.logging.file)
+            .map(|raw| paths::resolve_against(layout.root(), &raw))
+            .unwrap_or_else(|| layout.logs_dir().join("llm-gateway.log"))
+    }
+}
+
+fn non_empty_path(raw: &str) -> Option<String> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+/// Values coming from the command line that override the configuration file.
+#[derive(Debug, Clone, Default)]
+pub struct CliOverrides {
+    pub host: Option<String>,
+    pub port: Option<u16>,
+    pub browser_executable: Option<String>,
+    pub headless: Option<bool>,
+    pub profile_dir: Option<String>,
+    pub max_tabs: Option<usize>,
+    pub debug_screenshots: Option<bool>,
+    pub log_level: Option<String>,
+    pub log_format: Option<String>,
+    pub api_key: Option<String>,
+    pub attach: Option<bool>,
+    pub debug_port: Option<u16>,
+    pub stealth: Option<StealthMode>,
+    pub markdown: Option<MarkdownMode>,
+}
+
+impl GlobalConfig {
+    /// Apply CLI flags on top of the file configuration.
+    pub fn apply(&mut self, overrides: &CliOverrides) {
+        if let Some(host) = &overrides.host {
+            self.server.host = host.clone();
+        }
+        if let Some(port) = overrides.port {
+            self.server.port = port;
+        }
+        if let Some(key) = &overrides.api_key {
+            self.server.api_key = key.clone();
+        }
+        if let Some(exe) = &overrides.browser_executable {
+            self.browser.executable = exe.clone();
+        }
+        if let Some(headless) = overrides.headless {
+            self.browser.headless = headless;
+        }
+        if let Some(dir) = &overrides.profile_dir {
+            self.browser.profile_dir = dir.clone();
+        }
+        if let Some(max_tabs) = overrides.max_tabs {
+            self.browser.max_tabs = max_tabs;
+        }
+        if let Some(debug) = overrides.debug_screenshots {
+            self.debug.screenshots = if debug {
+                ScreenshotMode::Always
+            } else {
+                ScreenshotMode::OnError
+            };
+        }
+        if let Some(level) = &overrides.log_level {
+            self.logging.level = level.clone();
+        }
+        if let Some(format) = &overrides.log_format {
+            self.logging.format = format.clone();
+        }
+        if let Some(attach) = overrides.attach {
+            self.browser.attach = attach;
+        }
+        if let Some(port) = overrides.debug_port {
+            self.browser.debug_port = port;
+        }
+        if let Some(stealth) = overrides.stealth {
+            self.browser.stealth = stealth;
+        }
+        if let Some(markdown) = overrides.markdown {
+            self.capture.markdown = markdown;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn defaults_are_loopback_and_serialised() {
+        let cfg = GlobalConfig::default();
+        assert_eq!(cfg.server.host, "127.0.0.1");
+        assert_eq!(cfg.server.port, 8080);
+        assert_eq!(cfg.browser.max_tabs, 1);
+        assert_eq!(cfg.conversation.strategy, ConversationStrategy::Auto);
+        assert_eq!(cfg.capture.poll_interval_ms, 400);
+        cfg.validate().unwrap();
+        assert!(!cfg.server.is_public_bind());
+    }
+
+    #[test]
+    fn toml_round_trip_and_partial_files() {
+        let full = toml::to_string(&GlobalConfig::default()).unwrap();
+        let parsed = GlobalConfig::from_toml(&full).unwrap();
+        assert_eq!(parsed.server.port, 8080);
+
+        let partial = "[server]\nport = 9999\n";
+        let parsed = GlobalConfig::from_toml(partial).unwrap();
+        assert_eq!(parsed.server.port, 9999);
+        assert_eq!(parsed.server.host, "127.0.0.1");
+    }
+
+    #[test]
+    fn invalid_toml_is_a_config_error() {
+        let err = GlobalConfig::from_toml("port = ").unwrap_err();
+        assert_eq!(err.code(), "invalid_configuration");
+    }
+
+    #[test]
+    fn attach_mode_requires_a_port() {
+        let mut cfg = GlobalConfig::default();
+        assert_eq!(cfg.browser.stealth, StealthMode::Off);
+        assert_eq!(cfg.browser.debug_port, 9222);
+        cfg.browser.attach = true;
+        cfg.validate().unwrap();
+        cfg.browser.debug_port = 0;
+        assert!(cfg.validate().is_err());
+    }
+
+    #[test]
+    fn stealth_mode_is_parsed_from_the_file() {
+        let cfg = GlobalConfig::from_toml("[browser]\nstealth = \"aggressive\"\n").unwrap();
+        assert_eq!(cfg.browser.stealth, StealthMode::Aggressive);
+        let cfg = GlobalConfig::from_toml("[browser]\nstealth = \"minimal\"\n").unwrap();
+        assert_eq!(cfg.browser.stealth, StealthMode::Minimal);
+    }
+
+    #[test]
+    fn markdown_modes_are_parsed_and_default_to_auto() {
+        assert_eq!(
+            MarkdownMode::parse("clipboard").unwrap(),
+            MarkdownMode::Clipboard
+        );
+        assert_eq!(MarkdownMode::parse("DOM").unwrap(), MarkdownMode::Dom);
+        assert_eq!(MarkdownMode::parse(" text ").unwrap(), MarkdownMode::Text);
+        assert!(MarkdownMode::parse("rich").is_err());
+        assert_eq!(GlobalConfig::default().capture.markdown, MarkdownMode::Auto);
+        assert_eq!(GlobalConfig::default().capture.max_variants, 4);
+
+        let cfg = GlobalConfig::from_toml("[capture]\nmarkdown = \"text\"\n").unwrap();
+        assert_eq!(cfg.capture.markdown, MarkdownMode::Text);
+    }
+
+    #[test]
+    fn cli_overrides_win() {
+        let mut cfg = GlobalConfig::default();
+        cfg.apply(&CliOverrides {
+            port: Some(1234),
+            headless: Some(true),
+            debug_screenshots: Some(true),
+            ..Default::default()
+        });
+        assert_eq!(cfg.server.port, 1234);
+        assert!(cfg.browser.headless);
+        assert_eq!(cfg.debug.screenshots, ScreenshotMode::Always);
+    }
+
+    #[test]
+    fn paths_fall_back_to_the_layout() {
+        let layout = Layout::rooted_at(PathBuf::from("/state"));
+        let cfg = GlobalConfig::default();
+        assert_eq!(
+            cfg.resolved_profile_root(&layout),
+            PathBuf::from("/state/profiles")
+        );
+        assert_eq!(
+            cfg.profile_dir_for(&layout, "chatgpt"),
+            PathBuf::from("/state/profiles/chatgpt/user-data-dir")
+        );
+        assert_eq!(
+            cfg.resolved_store_path(&layout),
+            PathBuf::from("/state/conversations.json")
+        );
+    }
+}