feat: enhance API key management and working directory handling

milisp · claude · milisp · commit 1014430249de · 2025-08-22T22:36:16.000-04:00
Improve codex client configuration with proper API key handling through environment variables, fix working directory configuration to use current folder state, and update provider settings to use lowercase naming convention for consistency. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/src-tauri/src/codex_client.rs b/src-tauri/src/codex_client.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
 use serde_json;
 use std::process::Stdio;
+use std::collections::HashMap;
 use tauri::{AppHandle, Emitter};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
@@ -48,13 +49,64 @@ impl CodexClient {
             cmd.args(&args);
         }
         cmd.arg("proto");
+        
+        // Set up environment variables for API keys
+        let mut env_vars = HashMap::new();
+        log::debug!("Config provider: {}, API key present: {}", 
+                   config.provider, 
+                   config.api_key.as_ref().map_or(false, |k| !k.is_empty()));
+        
+        if let Some(api_key) = &config.api_key {
+            if !api_key.is_empty() {
+                log::debug!("API key provided, length: {}", api_key.len());
+                // Try to get the env_key from provider configuration first
+                if let Ok(providers) = read_model_providers().await {
+                    log::debug!("Successfully read providers, available: {:?}", providers.keys().collect::<Vec<_>>());
+                    
+                    // Try exact match first, then lowercase match
+                    let provider_config = providers.get(&config.provider)
+                        .or_else(|| providers.get(&config.provider.to_lowercase()));
+                    
+                    if let Some(provider_config) = provider_config {
+                        log::debug!("Found provider config: {:?}", provider_config);
+                        if !provider_config.env_key.is_empty() {
+                            log::debug!("Setting env var {} from provider config", provider_config.env_key);
+                            env_vars.insert(provider_config.env_key.clone(), api_key.clone());
+                        } else {
+                            log::debug!("Provider config has empty env_key");
+                        }
+                    } else {
+                        log::debug!("Provider {} not found in config", config.provider);
+                    }
+                } else {
+                    log::debug!("Failed to read providers, using fallback mapping");
+                    // Fallback mapping if config reading fails
+                    let env_var_name = match config.provider.as_str() {
+                        "gemini" => "GEMINI_API_KEY",
+                        "openai" => "OPENAI_API_KEY", 
+                        "openrouter" => "OPENROUTER_API_KEY",
+                        "ollama" => "OLLAMA_API_KEY",
+                        _ => "OPENAI_API_KEY", // fallback
+                    };
+                    log::debug!("Using fallback env var: {}", env_var_name);
+                    env_vars.insert(env_var_name.to_string(), api_key.clone());
+                }
+            } else {
+                log::debug!("API key is empty");
+            }
+        } else {
+            log::debug!("No API key provided");
+        }
 
         // Load provider configuration from config.toml if provider is specified
         if !config.provider.is_empty() && config.provider != "openai" {
             if let Ok(providers) = read_model_providers().await {
                 if let Ok(profiles) = read_profiles().await {
-                    // Check if there's a matching provider in config
-                    if let Some(provider_config) = providers.get(&config.provider) {
+                    // Check if there's a matching provider in config (try exact match first, then lowercase)
+                    let provider_config = providers.get(&config.provider)
+                        .or_else(|| providers.get(&config.provider.to_lowercase()));
+                    
+                    if let Some(provider_config) = provider_config {
                         // Set model provider based on config
                         cmd.arg("-c")
                             .arg(format!("model_provider={}", provider_config.name));
@@ -65,14 +117,13 @@ impl CodexClient {
                                 .arg(format!("base_url={}", provider_config.base_url));
                         }
 
-                        // Set API key environment variable reference
-                        if !provider_config.env_key.is_empty() {
-                            cmd.arg("-c")
-                                .arg(format!("api_key_env={}", provider_config.env_key));
-                        }
+                        // API key will be provided via environment variable - no need to modify provider config
 
                         // Use model from profile if available, otherwise from config
-                        let model_to_use = if let Some(profile) = profiles.get(&config.provider) {
+                        let profile = profiles.get(&config.provider)
+                            .or_else(|| profiles.get(&config.provider.to_lowercase()));
+                        
+                        let model_to_use = if let Some(profile) = profile {
                             &profile.model
                         } else {
                             &config.model
@@ -93,6 +144,8 @@ impl CodexClient {
                         if !config.model.is_empty() {
                             cmd.arg("-c").arg(format!("model={}", config.model));
                         }
+
+                        // API key will be provided via environment variable for custom providers
                     }
                 }
             } else {
@@ -107,6 +160,8 @@ impl CodexClient {
                 if !config.model.is_empty() {
                     cmd.arg("-c").arg(format!("model={}", config.model));
                 }
+
+                // API key will be provided via environment variable
             }
         } else {
             // Original logic for OSS and default cases
@@ -117,6 +172,8 @@ impl CodexClient {
             if !config.model.is_empty() {
                 cmd.arg("-c").arg(format!("model={}", config.model));
             }
+
+            // API key will be provided via environment variable for OpenAI
         }
 
         if !config.approval_policy.is_empty() {
@@ -140,7 +197,8 @@ impl CodexClient {
 
         // Set working directory for the process
         if !config.working_directory.is_empty() {
-            cmd.current_dir(&config.working_directory);
+            log::debug!("working_directory: {:?}", config.working_directory);
+            cmd.arg("-c").arg(format!("cwd={}", config.working_directory));
         }
 
         // Add custom arguments
@@ -153,10 +211,17 @@ impl CodexClient {
         // Print the command to be executed for debugging
         log::debug!("Starting codex with command: {:?}", cmd);
 
+        // Apply environment variables to the command
+        for (key, value) in &env_vars {
+            log::debug!("Setting environment variable: {}=***", key);
+            cmd.env(key, value);
+        }
+
         let mut process = cmd
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
+            .current_dir(&config.working_directory)
             .spawn()?;
 
         let stdin = process.stdin.take().expect("Failed to open stdin");
@@ -194,7 +259,7 @@ impl CodexClient {
             log::debug!("Starting stdout reader for session: {}", session_id_clone);
 
             while let Ok(Some(line)) = lines.next_line().await {
-                log::debug!("Received line from codex: {}", line);
+                // log::debug!("Received line from codex: {}", line);
                 if let Ok(event) = serde_json::from_str::<Event>(&line) {
                     // log::debug!("Parsed event: {:?}", event);
 
diff --git a/src-tauri/src/protocol.rs b/src-tauri/src/protocol.rs
@@ -138,4 +138,5 @@ pub struct CodexConfig {
     pub approval_policy: String,
     pub sandbox_mode: String,
     pub codex_path: Option<String>,
+    pub api_key: Option<String>,
 }
diff --git a/src/components/dialogs/ConfigDialog.tsx b/src/components/dialogs/ConfigDialog.tsx
@@ -217,7 +217,7 @@ export const ConfigDialog: React.FC<ConfigDialogProps> = ({
           <div className="space-y-2">
             <label className="text-sm font-medium">Command Preview</label>
             <div className="bg-gray-100 p-3 rounded text-sm font-mono">
-              cd {localConfig.workingDirectory || '.'} && {localConfig.codexPath || 'codex'} proto
+              {localConfig.codexPath || 'codex'} proto
               {currentProvider && currentModel && (
                 <>
                   {(() => {
@@ -230,6 +230,7 @@ export const ConfigDialog: React.FC<ConfigDialogProps> = ({
                   {` -c model=${currentModel}`}
                 </>
               )}
+              {` -c cwd=${localConfig.workingDirectory}`}
               {localConfig.approvalPolicy && ` -c approval_policy=${localConfig.approvalPolicy}`}
               {localConfig.sandboxMode && ` -c sandbox_mode=${localConfig.sandboxMode}`}
               {localConfig.customArgs && localConfig.customArgs.length > 0 && ` ${localConfig.customArgs.join(' ')}`}
diff --git a/src/pages/settings.tsx b/src/pages/settings.tsx
@@ -13,15 +13,15 @@ export default function SettingsPage() {
     setProviderModels,
   } = useSettingsStore();
   const [activeSection, setActiveSection] = useState("provider");
-  const [selectedProvider, setSelectedProvider] = useState<string>("OpenAI");
+  const [selectedProvider, setSelectedProvider] = useState<string>("openai");
   const [newModelName, setNewModelName] = useState("");
   const [editingModelIdx, setEditingModelIdx] = useState<number | null>(null);
   const [editingModelValue, setEditingModelValue] = useState("");
   const providerNames = [
-    "OpenAI",
-    "Gemini",
-    "Ollama",
-    "OpenRouter",
+    "openai",
+    "gemini",
+    "ollama",
+    "openrouter",
   ];
 
   return (
@@ -80,7 +80,7 @@ export default function SettingsPage() {
                 <div className="mb-4">
                   <label className="block mb-1 font-medium">API Key</label>
                   <Input
-                    type="text"
+                    type="password"
                     value={providers[selectedProvider as Provider]?.apiKey || ""}
                     onChange={(e) =>
                       setProviderApiKey(selectedProvider as Provider, e.target.value)
diff --git a/src/services/sessionManager.ts b/src/services/sessionManager.ts
@@ -1,5 +1,7 @@
 import { invoke } from '@tauri-apps/api/core';
 import { CodexConfig } from '@/types/codex';
+import { useFolderStore } from '@/stores/FolderStore';
+import { useSettingsStore } from '@/stores/SettingsStore';
 
 class SessionManager {
   private sessionConfigs: Map<string, CodexConfig> = new Map();
@@ -27,17 +29,30 @@ class SessionManager {
       
       console.log(`🚀 Starting backend session: ${rawSessionId} (from frontend: ${sessionId})`);
 
+      // Get current folder
+      const currentFolder = useFolderStore.getState().currentFolder;
+      
+      console.log(`📁 currentFolder: ${currentFolder})`);
+
+      // Get API key from settings store
+      const settingsStore = useSettingsStore.getState();
+      const providerConfig = settingsStore.providers[config.provider as keyof typeof settingsStore.providers];
+      const apiKey = providerConfig?.apiKey || null;
+      
+      console.log(`🔑 API key debug - Provider: ${config.provider}, Has API key: ${!!apiKey}, Length: ${apiKey?.length || 0}`);
+
       // Start the session (backend will check if already exists)
       await invoke('start_codex_session', {
         sessionId: rawSessionId,
         config: {
-          working_directory: config.workingDirectory,
+          working_directory: currentFolder,
           model: config.model,
           provider: config.provider,
           use_oss: config.useOss,
           custom_args: config.customArgs || null,
           approval_policy: config.approvalPolicy,
           sandbox_mode: config.sandboxMode,
+          api_key: apiKey,
         },
       });
 
diff --git a/src/stores/SettingsStore.ts b/src/stores/SettingsStore.ts
@@ -1,7 +1,7 @@
 import { create } from "zustand";
 import { persist } from "zustand/middleware";
 
-export type Provider = "OpenAI" | "Gemini" | "Ollama" | "OpenRouter";
+export type Provider = "openai" | "gemini" | "ollama" | "openrouter";
 
 type ProviderConfig = {
   apiKey: string;
@@ -39,23 +39,23 @@ const DEFAULT_EXCLUDE_FOLDERS = [
 ];
 
 const DEFAULT_PROVIDERS: Providers = {
-  OpenAI: {
-    apiKey: "OPENAI_API_KEY",
+  openai: {
+    apiKey: "",
     baseUrl: "",
-    models: ["gpt-5", "gpt-4o", "gpt-4o-mini", "gpt-3.5-turbo"],
+    models: ["gpt-5", "gpt-5-mini", "gpt-5-nano", "gpt-4o", "gpt-4o-mini"],
   },
-  Ollama: {
-    apiKey: "OLLAMA_API_KEY",
+  ollama: {
+    apiKey: "",
     baseUrl: "http://localhost:11434/v1",
     models: ["gpt-oss:20b", "gpt-oss:120b", "mistral", "qwen3", "deepseek-r1", "llama3.2"],
   },
-  Gemini: {
-    apiKey: "GEMINI_API_KEY",
+  gemini: {
+    apiKey: "",
     baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
     models: ["gemini-2.5-flash", "gemini-2.5-pro"],
   },
-  OpenRouter: {
-    apiKey: "OPENROUTER_API_KEY",
+  openrouter: {
+    apiKey: "",
     baseUrl: "https://openrouter.ai/api/v1",
     models: [
       "anthropic/claude-opus-4.1",
@@ -72,7 +72,7 @@ export const useSettingsStore = create<SettingsStore>()(
     (set) => ({
       excludeFolders: DEFAULT_EXCLUDE_FOLDERS,
       providers: { ...DEFAULT_PROVIDERS },
-      defaultProvider: "OpenAI",
+      defaultProvider: "openai",
       addExcludeFolder: (folder: string) =>
         set((state) => ({
           excludeFolders: [...state.excludeFolders, folder],

Original file line number	Diff line number	Diff line change
`@@ -138,4 +138,5 @@ pub struct CodexConfig {`
`138`	`138`	`pub approval_policy: String,`
`139`	`139`	`pub sandbox_mode: String,`
`140`	`140`	`pub codex_path: Option<String>,`
	`141`	`+ pub api_key: Option<String>,`
`141`	`142`	`}`