fix

Author: zhujian0805

code_assistant_manager/tools.yaml

@@ -50,7 +50,7 @@ tools:
         - "-c profiles.custom.model={selected_model}"
         - "-c profiles.custom.model_provider=custom"
         - "-c profiles.custom.model_reasoning_effort=low"
-        - "-c model_providers.custom.env_key=OPENAI_API_KEY"
+        - "-c model_providers.custom.env_key={api_key_env}"
         - "-p custom"
 
   qwen-code:

frontend/src/pages/Providers.tsx

@@ -16,6 +16,10 @@ export function Providers() {
   // users can set/replace the key on providers that predate the field.
   const [keyDraft, setKeyDraft] = useState<Record<string, string>>({})
   const [keyStatus, setKeyStatus] = useState<Record<string, string>>({})
+  // Per-provider draft API-key env-var name (used by tools like codex that read
+  // the key from an env var named by env_key).
+  const [envDraft, setEnvDraft] = useState<Record<string, string>>({})
+  const [envStatus, setEnvStatus] = useState<Record<string, string>>({})
 
   async function reload() { setProviders(await api.listProviders()) }
   useEffect(() => { void reload() }, [])
@@ -42,6 +46,21 @@ export function Providers() {
     }
   }
 
+  async function saveApiKeyEnv(provider: Provider) {
+    const value = envDraft[provider.name] ?? ''
+    if (!value) return
+    setEnvStatus((s) => ({ ...s, [provider.name]: t('providers.apiKeySaving') }))
+    try {
+      const updated = await api.updateProvider(provider.name, { apiKeyEnv: value })
+      setProviders((items) => items.map((item) => item.name === provider.name ? updated : item))
+      setEnvDraft((d) => ({ ...d, [provider.name]: '' }))
+      setEnvStatus((s) => ({ ...s, [provider.name]: t('providers.apiKeySaved') }))
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      setEnvStatus((s) => ({ ...s, [provider.name]: message }))
+    }
+  }
+
   async function toggle(provider: Provider) {
     const updated = await api.toggleProvider(provider.name, !provider.enabled)
     setProviders((items) => items.map((item) => item.name === provider.name ? updated : item))
@@ -101,6 +120,22 @@ export function Providers() {
               </div>
             </dd>
           </div>
+          <div>
+            <dt>{t('providers.setApiKeyEnv')}</dt>
+            <dd>
+              <div className="inline-form">
+                <input
+                  aria-label={`${t('providers.setApiKeyEnv')} ${p.name}`}
+                  type="text"
+                  placeholder="OMNILLM_API_KEY"
+                  value={envDraft[p.name] ?? ''}
+                  onChange={(event) => setEnvDraft((d) => ({ ...d, [p.name]: event.target.value }))}
+                />
+                <button onClick={() => saveApiKeyEnv(p)} disabled={!(envDraft[p.name] ?? '').length}>{t('providers.apiKeySave')}</button>
+                {envStatus[p.name] && <span style={{ fontSize: '0.85em' }}>{envStatus[p.name]}</span>}
+              </div>
+            </dd>
+          </div>
           <div><dt>{t('providers.clients')}</dt><dd>{p.clients.join(', ') || '—'}</dd></div>
         </dl>
       )}

frontend/src/services/i18n.ts

@@ -27,6 +27,7 @@ const en: Record<string, string> = {
   'providers.apiKeyPlaceholder': 'sk-… (stored with provider)',
   'providers.apiKeyHint': 'Literal API key stored with the provider and written into agent configs. Takes precedence over the env var.',
   'providers.setApiKey': 'Set API key',
+  'providers.setApiKeyEnv': 'Set API key env var',
   'providers.apiKeySave': 'Save key',
   'providers.apiKeySaving': 'Saving…',
   'providers.apiKeySaved': 'Saved.',
@@ -112,6 +113,7 @@ const zh: Record<string, string> = {
   'providers.apiKeyPlaceholder': 'sk-…（与提供商一起保存）',
   'providers.apiKeyHint': '与提供商一起保存并写入各代理配置的 API 密钥，优先级高于环境变量。',
   'providers.setApiKey': '设置 API 密钥',
+  'providers.setApiKeyEnv': '设置 API 密钥环境变量',
   'providers.apiKeySave': '保存密钥',
   'providers.apiKeySaving': '保存中…',
   'providers.apiKeySaved': '已保存。',

internal/desktop/tool_cache.go

@@ -0,0 +1,122 @@
+package desktop
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/chat2anyllm/code-agent-manager/internal/pathutil"
+)
+
+// detectionTTL bounds how long a cached tool-detection result is served
+// without re-probing the binary. Each probe spawns a subprocess (`<bin>
+// --version`), which is the dominant cost of the Agents page; CLI
+// install/version state changes rarely, so even a short TTL makes repeat
+// page loads instant while still picking up installs/upgrades within the
+// window. Mirrors the model-discovery cache TTL convention in
+// internal/providers/models.go.
+const detectionTTL = 5 * time.Minute
+
+// detectionEntry is one cached tool-detection result.
+type detectionEntry struct {
+	Installed  bool      `json:"installed"`
+	Version    string    `json:"version"`
+	DetectedAt time.Time `json:"detected_at"`
+}
+
+// detectionCacheFile is the on-disk shape at cachePath().
+type detectionCacheFile struct {
+	Tools map[string]detectionEntry `json:"tools"`
+}
+
+// detectionCache memoizes tool-detection results. It is held on the
+// long-lived sidecar ToolService, so the in-memory map makes repeat
+// Agents-page loads free within a process; the on-disk file additionally
+// lets a freshly started sidecar serve the last-known results immediately.
+type detectionCache struct {
+	mu      sync.RWMutex
+	loaded  bool // disk has been read into entries
+	path    string
+	entries map[string]detectionEntry
+}
+
+func newDetectionCache() *detectionCache {
+	return &detectionCache{
+		path:    filepath.Join(pathutil.CacheDir(), "tools", "detection.json"),
+		entries: map[string]detectionEntry{},
+	}
+}
+
+// loadOnce reads the on-disk cache into memory the first time it is called.
+// Best-effort: a missing or corrupt file leaves the cache empty so callers
+// fall through to a fresh probe.
+func (c *detectionCache) loadOnce() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.loaded {
+		return
+	}
+	c.loaded = true
+	raw, err := os.ReadFile(c.path)
+	if err != nil {
+		return
+	}
+	var file detectionCacheFile
+	if err := json.Unmarshal(raw, &file); err != nil {
+		return
+	}
+	for name, entry := range file.Tools {
+		c.entries[name] = entry
+	}
+}
+
+// get returns the cached entry for name and whether it is still fresh
+// (within detectionTTL). A stale or missing entry reports fresh=false so the
+// caller knows to re-probe.
+func (c *detectionCache) get(name string) (detectionEntry, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	entry, ok := c.entries[name]
+	if !ok {
+		return detectionEntry{}, false
+	}
+	if entry.DetectedAt.IsZero() || time.Since(entry.DetectedAt) > detectionTTL {
+		return entry, false
+	}
+	return entry, true
+}
+
+// put stores a fresh detection result.
+func (c *detectionCache) put(name string, installed bool, version string) {
+	c.mu.Lock()
+	c.entries[name] = detectionEntry{Installed: installed, Version: version, DetectedAt: time.Now()}
+	c.mu.Unlock()
+}
+
+// persist writes the in-memory entries to disk atomically. Best-effort: a
+// write failure only means the next cold start re-probes, which is correct.
+func (c *detectionCache) persist() {
+	c.mu.RLock()
+	file := detectionCacheFile{Tools: make(map[string]detectionEntry, len(c.entries))}
+	for name, entry := range c.entries {
+		file.Tools[name] = entry
+	}
+	path := c.path
+	c.mu.RUnlock()
+
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return
+	}
+	payload, err := json.MarshalIndent(file, "", "  ")
+	if err != nil {
+		return
+	}
+	tmp := fmt.Sprintf("%s.tmp.%d", path, os.Getpid())
+	if err := os.WriteFile(tmp, payload, 0o600); err != nil {
+		return
+	}
+	_ = os.Rename(tmp, path)
+}

internal/desktop/tool_cache_test.go

@@ -0,0 +1,125 @@
+package desktop
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// withTempCacheDir points the detection cache at an isolated temp directory
+// for the test and restores the original value on cleanup.
+func withTempCacheDir(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	previous := os.Getenv("CAM_CACHE_DIR")
+	os.Setenv("CAM_CACHE_DIR", dir)
+	t.Cleanup(func() { os.Setenv("CAM_CACHE_DIR", previous) })
+	return dir
+}
+
+func TestDetectionCacheGetMissing(t *testing.T) {
+	cache := newDetectionCache()
+	cache.loadOnce()
+
+	if _, fresh := cache.get("does-not-exist"); fresh {
+		t.Fatal("missing entry should not be fresh")
+	}
+}
+
+func TestDetectionCachePutThenGetFresh(t *testing.T) {
+	cache := newDetectionCache()
+	cache.loadOnce()
+
+	cache.put("claude-code", true, "1.2.3")
+	entry, fresh := cache.get("claude-code")
+	if !fresh {
+		t.Fatal("just-cached entry should be fresh")
+	}
+	if !entry.Installed || entry.Version != "1.2.3" {
+		t.Fatalf("entry = %+v, want {Installed:true Version:1.2.3}", entry)
+	}
+}
+
+func TestDetectionCacheStaleAfterTTL(t *testing.T) {
+	cache := newDetectionCache()
+	cache.loadOnce()
+	cache.put("gemini-cli", true, "9.9.9")
+
+	// Backdate the entry past detectionTTL so it reads as stale.
+	cache.mu.Lock()
+	e := cache.entries["gemini-cli"]
+	e.DetectedAt = time.Now().Add(-detectionTTL - time.Second)
+	cache.entries["gemini-cli"] = e
+	cache.mu.Unlock()
+
+	if _, fresh := cache.get("gemini-cli"); fresh {
+		t.Fatal("backdated entry should be stale")
+	}
+}
+
+func TestDetectionCachePersistLoadRoundTrip(t *testing.T) {
+	withTempCacheDir(t)
+	cache := newDetectionCache()
+	cache.loadOnce()
+
+	cache.put("claude-code", true, "1.2.3")
+	cache.put("gemini-cli", false, "")
+	cache.persist()
+
+	// A fresh cache over the same on-disk file should see both entries.
+	loaded := newDetectionCache()
+	loaded.loadOnce()
+	if _, fresh := loaded.get("claude-code"); !fresh {
+		t.Fatal("claude-code should load from disk fresh")
+	}
+	if _, fresh := loaded.get("gemini-cli"); !fresh {
+		t.Fatal("gemini-cli should load from disk fresh")
+	}
+}
+
+func TestDetectionCacheWritesToToolsSubdir(t *testing.T) {
+	dir := withTempCacheDir(t)
+	cache := newDetectionCache()
+	cache.loadOnce()
+	cache.put("claude-code", true, "1.0.0")
+	cache.persist()
+
+	path := filepath.Join(dir, "tools", "detection.json")
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read cache file: %v", err)
+	}
+	var file detectionCacheFile
+	if err := json.Unmarshal(raw, &file); err != nil {
+		t.Fatalf("unmarshal cache file: %v", err)
+	}
+	if entry, ok := file.Tools["claude-code"]; !ok || entry.Version != "1.0.0" {
+		t.Fatalf("cache file = %+v, want claude-code 1.0.0", file.Tools)
+	}
+}
+
+func TestDetectionCacheLoadMissingFileIsNoOp(t *testing.T) {
+	withTempCacheDir(t)
+	cache := newDetectionCache()
+	cache.loadOnce() // no file exists yet
+	if _, fresh := cache.get("anything"); fresh {
+		t.Fatal("empty cache should report nothing fresh")
+	}
+}
+
+func TestDetectionCacheLoadCorruptFileIsNoOp(t *testing.T) {
+	dir := withTempCacheDir(t)
+	if err := os.MkdirAll(filepath.Join(dir, "tools"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "tools", "detection.json"), []byte("{not json"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cache := newDetectionCache()
+	cache.loadOnce() // corrupt file must not panic or pollute
+	if _, fresh := cache.get("anything"); fresh {
+		t.Fatal("corrupt cache file should leave nothing fresh")
+	}
+}