Warn instead of silently storing plaintext API keys; fix runtime-manager polling storm; add ManagedPythonWorker timeouts

- secrets-store: expose isEncryptionAvailable() and log a warning when
  falling back to unencrypted storage (no OS credential store available).
  Settings now shows a prominent plaintext-storage warning in that case
  instead of the normal "encrypted at rest" note, and the README/docs
  no longer claim unconditional encryption.
- RuntimeManager: stop re-running full Python environment inspection
  (which can spawn nvidia-smi/rocminfo/wsl.exe and a Python interpreter
  per family) on the same 2.5s interval as lightweight process-status
  polling. Environment status now refreshes once on page entry and on
  manual refresh instead.
- ManagedPythonWorker: add a per-request timeout so a hung-but-alive
  worker can't leave a request pending forever, an output buffer cap to
  bound memory from a runaway/non-responsive worker, and safe handling
  of malformed response lines instead of an unguarded JSON.parse.

Author: voidstackloop

README.md

@@ -209,7 +209,7 @@ The `app` suite covers the store layer (atomic writes, corrupted-file recovery),
 
 - **Process isolation**: `contextIsolation: true`, `nodeIntegration: false` — the renderer only ever talks to the main process through an explicit, typed preload bridge.
 - **Content Security Policy** restricting plugins, frames, and form submissions; external links open in your default browser instead of an unmanaged Electron window.
-- **API keys** are encrypted at rest via the OS credential store (`safeStorage`) and never leave the device.
+- **API keys** are encrypted at rest via the OS credential store (`safeStorage`) and never leave the device. On the rare system with no OS credential store available (e.g. some keyring-less Linux setups), keys fall back to being stored in plain text on disk rather than being silently dropped — Settings shows a prominent warning in that case rather than the normal "encrypted" note.
 - **Agent mode** tool calls are workspace-sandboxed (path-traversal rejected) and require explicit per-call approval — see [Agent mode](#agent-mode) above and [docs/AGENT_MODE.md](docs/AGENT_MODE.md) for the full detail.
 - No telemetry, no analytics, no data sent anywhere except directly to whichever provider (Ollama, OpenAI, Anthropic) you've configured.
 

app/src/main.ts

@@ -738,6 +738,7 @@ function registerIpcHandlers(): void {
     ipcMain.handle("secrets:set", (_event: IpcMainInvokeEvent, { key, value }: { key: string; value: string }) =>
         secretsStore.setSecret(requireString(key, "secret key"), value ?? "")
     );
+    ipcMain.handle("secrets:isEncryptionAvailable", () => secretsStore.isEncryptionAvailable());
 
     ipcMain.handle("accounts:status", (_event: IpcMainInvokeEvent, provider: accounts.AccountProvider) =>
         accounts.getLinkedAccount(provider)

app/src/preload.ts

@@ -177,6 +177,7 @@ contextBridge.exposeInMainWorld("api", {
     secrets: {
         has: (key: string) => ipcRenderer.invoke("secrets:has", key),
         set: (key: string, value: string) => ipcRenderer.invoke("secrets:set", { key, value }),
+        isEncryptionAvailable: () => ipcRenderer.invoke("secrets:isEncryptionAvailable") as Promise<boolean>,
     },
 
     accounts: {

app/src/python-runtime-manager.ts

@@ -137,8 +137,20 @@ export async function getPythonEnvironmentStatuses(): Promise<PythonEnvironmentS
 }
 
 interface WorkerResponse { protocol: number; id: string; ok: boolean; result?: unknown; error?: { code: string; message: string } }
+// A request has no inherent deadline otherwise: if the worker process stays
+// alive but stops responding (stuck in a long computation, deadlocked, or
+// just never writes a line back), the promise in `pending` would never
+// settle and would leak forever.
+const REQUEST_TIMEOUT_MS = 20_000;
+// Bounds how much unterminated stdout `consume` will buffer waiting for a
+// newline. A worker that never emits one (buggy print, corrupted output)
+// would otherwise grow this string without limit for as long as the process
+// lives — this caps the damage and fails loudly instead of leaking memory.
+const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 export class ManagedPythonWorker {
-    private child: ChildProcess | null = null; private pending = new Map<string, { resolve(value: unknown): void; reject(error: Error): void }>(); private buffer = "";
+    private child: ChildProcess | null = null;
+    private pending = new Map<string, { resolve(value: unknown): void; reject(error: Error): void; timer: NodeJS.Timeout }>();
+    private buffer = "";
     constructor(private readonly family: PythonRuntimeFamily) {}
     start(): void {
         if (this.child) return;
@@ -153,10 +165,54 @@ export class ManagedPythonWorker {
         // event with no listener, which Node treats as an uncaught exception
         // and crashes the whole main process instead of just failing this
         // one request.
-        this.child.once("error", (error: Error) => { for (const request of this.pending.values()) request.reject(error); this.pending.clear(); this.child = null; });
-        this.child.once("exit", () => { for (const request of this.pending.values()) request.reject(new Error("Python worker exited")); this.pending.clear(); this.child = null; });
+        this.child.once("error", (error: Error) => { this.failAllPending(error); this.child = null; });
+        this.child.once("exit", () => { this.failAllPending(new Error("Python worker exited")); this.child = null; });
+    }
+    private failAllPending(error: Error): void {
+        for (const request of this.pending.values()) { clearTimeout(request.timer); request.reject(error); }
+        this.pending.clear();
+        this.buffer = "";
+    }
+    private consume(chunk: string): void {
+        this.buffer += chunk;
+        if (this.buffer.length > MAX_BUFFER_BYTES) {
+            // Something is badly wrong (runaway output, no newlines) — treat
+            // it as fatal rather than let the process keep growing memory.
+            const error = new Error(`Python worker "${this.family}" exceeded the ${MAX_BUFFER_BYTES}-byte output buffer without a complete line`);
+            const child = this.child;
+            this.failAllPending(error);
+            if (child?.pid) killProcessTree(child.pid, "SIGKILL");
+            this.child = null;
+            return;
+        }
+        const lines = this.buffer.split(/\r?\n/); this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line) continue;
+            let response: WorkerResponse;
+            try {
+                response = JSON.parse(line) as WorkerResponse;
+            } catch {
+                console.error(`[python-worker:${this.family}] Ignoring malformed response line: ${line.slice(0, 200)}`);
+                continue;
+            }
+            const pending = this.pending.get(response.id);
+            if (!pending) continue;
+            clearTimeout(pending.timer);
+            this.pending.delete(response.id);
+            response.ok ? pending.resolve(response.result) : pending.reject(new Error(response.error?.message ?? "Worker request failed"));
+        }
+    }
+    request(method: "health" | "metrics" | "recommend", params: Record<string, unknown> = {}): Promise<unknown> {
+        this.start();
+        const id = crypto.randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Python worker "${this.family}" request "${method}" timed out after ${REQUEST_TIMEOUT_MS}ms`));
+            }, REQUEST_TIMEOUT_MS);
+            this.pending.set(id, { resolve, reject, timer });
+            this.child?.stdin?.write(JSON.stringify({ protocol: PYTHON_WORKER_PROTOCOL_VERSION, id, method, params }) + "\n");
+        });
     }
-    private consume(chunk: string): void { this.buffer += chunk; const lines = this.buffer.split(/\r?\n/); this.buffer = lines.pop() ?? ""; for (const line of lines) { if (!line) continue; const response = JSON.parse(line) as WorkerResponse; const pending = this.pending.get(response.id); if (!pending) continue; this.pending.delete(response.id); response.ok ? pending.resolve(response.result) : pending.reject(new Error(response.error?.message ?? "Worker request failed")); } }
-    request(method: "health" | "metrics" | "recommend", params: Record<string, unknown> = {}): Promise<unknown> { this.start(); const id = crypto.randomUUID(); return new Promise((resolve, reject) => { this.pending.set(id, { resolve, reject }); this.child?.stdin?.write(JSON.stringify({ protocol: PYTHON_WORKER_PROTOCOL_VERSION, id, method, params }) + "\n"); }); }
     async shutdown(): Promise<void> { const child = this.child; if (!child) return; const pid = child.pid; try { const id = crypto.randomUUID(); child.stdin?.write(JSON.stringify({ protocol: PYTHON_WORKER_PROTOCOL_VERSION, id, method: "shutdown", params: {} }) + "\n"); } catch { /* pipe closed */ } await new Promise((resolve) => setTimeout(resolve, 500)); if (pid && this.child) killProcessTree(pid, "SIGTERM"); this.child = null; }
 }

app/src/secrets-store.ts

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { app, safeStorage } from "electron";
 import { readJson, writeJson } from "./json-store";
+import { logger } from "./logger";
 
 function filePath(): string {
     return path.join(app.getPath("userData"), "secrets.json");
@@ -14,15 +15,27 @@ function writeAll(data: Record<string, string>): void {
     writeJson(filePath(), data);
 }
 
+// Exposed so callers (and Settings UI) can warn the user before a key ends
+// up unencrypted, rather than only finding out after the fact.
+export function isEncryptionAvailable(): boolean {
+    return safeStorage.isEncryptionAvailable();
+}
+
+// Environments without an OS credential store (e.g. some Linux setups with no
+// keyring) can't use safeStorage at all. We still allow storing the key there
+// rather than silently dropping it or hard-blocking the feature, but this is
+// no longer a silent fallback: it's logged at warn level (surfaced in Settings
+// -> Diagnostics -> Copy diagnostic info) and the Settings UI checks
+// isEncryptionAvailable() up front to show a plaintext-storage warning next to
+// every API key field instead of the normal "encrypted at rest" note.
 export function setSecret(key: string, value: string): void {
     const all = readAll();
     if (!value) {
         delete all[key];
     } else if (safeStorage.isEncryptionAvailable()) {
         all[key] = safeStorage.encryptString(value).toString("base64");
     } else {
-        // Fallback for environments without an OS credential store (e.g. some
-        // Linux setups with no keyring). Better to work than to silently drop the key.
+        logger.warn(`No OS credential store available; storing secret "${key}" unencrypted in secrets.json`);
         all[key] = value;
     }
     writeAll(all);

docs/ARCHITECTURE.md

@@ -102,7 +102,12 @@ plain JSON files under Electron's `userData` directory, going through the shared
 
 Secrets (provider API keys) go through `secrets-store.ts` instead, which encrypts values at rest
 via Electron's `safeStorage` (backed by the OS credential store — Keychain, DPAPI, or
-libsecret/kwallet) rather than writing them out as plain JSON.
+libsecret/kwallet) rather than writing them out as plain JSON. On a system with no OS credential
+store available (`safeStorage.isEncryptionAvailable()` returns `false` — some keyring-less Linux
+setups), the store falls back to writing the value unencrypted rather than silently dropping the
+key; this fallback is logged at warn level, and `secrets:isEncryptionAvailable` lets the renderer
+check the same condition to show a plaintext-storage warning in Settings instead of the normal
+"encrypted at rest" note.
 
 ## Native addon (`lib/`)
 

frontend/src/lib/translations.ts

@@ -50,6 +50,7 @@ export interface Dictionary {
     yourSystem: string;
     cloudProviders: string;
     keysEncryptedNote: string;
+    keysNotEncryptedWarning: string;
     ollamaModelsSection: string;
     otherInstalledModels: string;
     chatDefaults: string;
@@ -450,6 +451,7 @@ export const en: Dictionary = {
     yourSystem: "Your system",
     cloudProviders: "Cloud providers",
     keysEncryptedNote: "Keys are encrypted at rest using your OS credential store and never leave this device.",
+    keysNotEncryptedWarning: "No OS credential store was found on this system, so keys are being saved in plain text on disk instead of encrypted. They still never leave this device, but anyone with file access to your user profile can read them.",
     ollamaModelsSection: "Ollama models",
     otherInstalledModels: "Other installed models",
     chatDefaults: "Chat defaults",
@@ -860,6 +862,8 @@ export const tr: Dictionary = {
     cloudProviders: "Bulut sağlayıcılar",
     keysEncryptedNote:
         "Anahtarlar, işletim sistemi kimlik bilgisi deposu kullanılarak şifrelenir ve bu cihazdan çıkmaz.",
+    keysNotEncryptedWarning:
+        "Bu sistemde bir işletim sistemi kimlik bilgisi deposu bulunamadığı için anahtarlar şifrelenmeden düz metin olarak diske kaydediliyor. Yine de bu cihazdan çıkmazlar, ancak kullanıcı profilinize dosya erişimi olan herkes onları okuyabilir.",
     ollamaModelsSection: "Ollama modelleri",
     otherInstalledModels: "Diğer yüklü modeller",
     chatDefaults: "Sohbet varsayılanları",