fix: sync steer toggle to config.toml

Author: Dimillian

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -1,5 +1,7 @@
 #[path = "../backend/mod.rs"]
 mod backend;
+#[path = "../codex_config.rs"]
+mod codex_config;
 #[path = "../storage.rs"]
 mod storage;
 #[path = "../types.rs"]
@@ -204,6 +206,7 @@ impl DaemonState {
     }
 
     async fn update_app_settings(&self, settings: AppSettings) -> Result<AppSettings, String> {
+        let _ = codex_config::write_steer_enabled(settings.experimental_steer_enabled);
         write_settings(&self.settings_path, &settings)?;
         let mut current = self.app_settings.lock().await;
         *current = settings.clone();
@@ -688,8 +691,11 @@ async fn handle_rpc_request(
             serde_json::to_value(files).map_err(|err| err.to_string())
         }
         "get_app_settings" => {
-            let settings = state.app_settings.lock().await;
-            serde_json::to_value(settings.clone()).map_err(|err| err.to_string())
+            let mut settings = state.app_settings.lock().await.clone();
+            if let Ok(Some(steer_enabled)) = codex_config::read_steer_enabled() {
+                settings.experimental_steer_enabled = steer_enabled;
+            }
+            serde_json::to_value(settings).map_err(|err| err.to_string())
         }
         "update_app_settings" => {
             let settings_value = match params {

src-tauri/src/codex_config.rs

@@ -0,0 +1,142 @@
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+const FEATURES_TABLE: &str = "[features]";
+
+pub(crate) fn read_steer_enabled() -> Result<Option<bool>, String> {
+    read_feature_flag("steer")
+}
+
+pub(crate) fn write_steer_enabled(enabled: bool) -> Result<(), String> {
+    write_feature_flag("steer", enabled)
+}
+
+fn read_feature_flag(key: &str) -> Result<Option<bool>, String> {
+    let path = config_toml_path().ok_or("Unable to resolve CODEX_HOME".to_string())?;
+    if !path.exists() {
+        return Ok(None);
+    }
+    let contents = fs::read_to_string(&path).map_err(|err| err.to_string())?;
+    Ok(find_feature_flag(&contents, key))
+}
+
+fn write_feature_flag(key: &str, enabled: bool) -> Result<(), String> {
+    let Some(path) = config_toml_path() else {
+        return Ok(());
+    };
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+    }
+    let contents = fs::read_to_string(&path).unwrap_or_default();
+    let updated = upsert_feature_flag(&contents, key, enabled);
+    fs::write(&path, updated).map_err(|err| err.to_string())
+}
+
+fn config_toml_path() -> Option<PathBuf> {
+    resolve_codex_home().map(|home| home.join("config.toml"))
+}
+
+fn resolve_codex_home() -> Option<PathBuf> {
+    if let Ok(value) = env::var("CODEX_HOME") {
+        if !value.trim().is_empty() {
+            return Some(PathBuf::from(value.trim()));
+        }
+    }
+    resolve_home_dir().map(|home| home.join(".codex"))
+}
+
+fn resolve_home_dir() -> Option<PathBuf> {
+    if let Ok(value) = env::var("HOME") {
+        if !value.trim().is_empty() {
+            return Some(PathBuf::from(value));
+        }
+    }
+    if let Ok(value) = env::var("USERPROFILE") {
+        if !value.trim().is_empty() {
+            return Some(PathBuf::from(value));
+        }
+    }
+    None
+}
+
+fn find_feature_flag(contents: &str, key: &str) -> Option<bool> {
+    let mut in_features = false;
+    for line in contents.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('[') && trimmed.ends_with(']') {
+            in_features = trimmed == FEATURES_TABLE;
+            continue;
+        }
+        if !in_features || trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        let (candidate_key, value) = trimmed.split_once('=')?;
+        if candidate_key.trim() != key {
+            continue;
+        }
+        let value = value.split('#').next().unwrap_or("").trim();
+        return match value {
+            "true" => Some(true),
+            "false" => Some(false),
+            _ => None,
+        };
+    }
+    None
+}
+
+fn upsert_feature_flag(contents: &str, key: &str, enabled: bool) -> String {
+    let mut lines: Vec<String> = contents.lines().map(|line| line.to_string()).collect();
+    let mut in_features = false;
+    let mut features_start: Option<usize> = None;
+    let mut features_end: Option<usize> = None;
+    let mut key_index: Option<usize> = None;
+
+    for (idx, line) in lines.iter().enumerate() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('[') && trimmed.ends_with(']') {
+            if in_features {
+                features_end = Some(idx);
+                break;
+            }
+            in_features = trimmed == FEATURES_TABLE;
+            if in_features {
+                features_start = Some(idx);
+            }
+            continue;
+        }
+        if !in_features || trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        if let Some((candidate_key, _)) = trimmed.split_once('=') {
+            if candidate_key.trim() == key {
+                key_index = Some(idx);
+                break;
+            }
+        }
+    }
+
+    let flag_line = format!("{key} = {}", if enabled { "true" } else { "false" });
+
+    if let Some(start) = features_start {
+        let end = features_end.unwrap_or(lines.len());
+        if let Some(index) = key_index {
+            lines[index] = flag_line;
+        } else {
+            let insert_at = if end > start + 1 { end } else { start + 1 };
+            lines.insert(insert_at, flag_line);
+        }
+    } else {
+        if !lines.is_empty() && !lines.last().unwrap().trim().is_empty() {
+            lines.push(String::new());
+        }
+        lines.push(FEATURES_TABLE.to_string());
+        lines.push(flag_line);
+    }
+
+    let mut updated = lines.join("\n");
+    if contents.ends_with('\n') || updated.is_empty() {
+        updated.push('\n');
+    }
+    updated
+}

src-tauri/src/git.rs

@@ -127,7 +127,7 @@ fn parse_pr_diff(diff: &str) -> Vec<GitHubPullRequestDiff> {
     let mut current_new_path: Option<String> = None;
     let mut current_status: Option<String> = None;
 
-    let mut finalize = |lines: &Vec<&str>,
+    let finalize = |lines: &Vec<&str>,
                         old_path: &Option<String>,
                         new_path: &Option<String>,
                         status: &Option<String>,

src-tauri/src/lib.rs

@@ -3,6 +3,7 @@ use tauri::{Manager, WebviewUrl, WebviewWindowBuilder};
 
 mod backend;
 mod codex;
+mod codex_config;
 mod dictation;
 mod event_sink;
 mod git;

src-tauri/src/settings.rs

@@ -1,20 +1,25 @@
 use tauri::State;
 
+use crate::codex_config;
 use crate::state::AppState;
 use crate::storage::write_settings;
 use crate::types::AppSettings;
 
 #[tauri::command]
 pub(crate) async fn get_app_settings(state: State<'_, AppState>) -> Result<AppSettings, String> {
-    let settings = state.app_settings.lock().await;
-    Ok(settings.clone())
+    let mut settings = state.app_settings.lock().await.clone();
+    if let Ok(Some(steer_enabled)) = codex_config::read_steer_enabled() {
+        settings.experimental_steer_enabled = steer_enabled;
+    }
+    Ok(settings)
 }
 
 #[tauri::command]
 pub(crate) async fn update_app_settings(
     settings: AppSettings,
     state: State<'_, AppState>,
 ) -> Result<AppSettings, String> {
+    let _ = codex_config::write_steer_enabled(settings.experimental_steer_enabled);
     write_settings(&state.settings_path, &settings)?;
     let mut current = state.app_settings.lock().await;
     *current = settings.clone();