fix(electron): decrypt keys after ready and harden navigation and IPC

- Apply preset env after app ready, so Windows/Linux get decrypted keys
- Never re-encrypt ciphertext; restore env when switching or removing presets
- Block navigation away from the app, open external links in the browser, check IPC senders
- Keep inherited proxy settings, default NO_PROXY for localhost
- Serialize server start/restart, kill stuck processes, follow port changes
- Atomic config writes, keep corrupt files as backups, remember the server port
- Menu and settings window stay in sync; dev script gets the decrypted preset env
- Use app.isPackaged, parse inline .env comments, drop .env files from the bundle

electron/main/next-server.ts

@@ -6,10 +6,22 @@ import {
     getAllocatedPort,
     getServerUrl,
     isPortAvailable,
+    saveServerPort,
 } from "./port-manager"
+import { setAppUrl } from "./window-manager"
 
 let serverProcess: UtilityProcess | null = null
 
+// Start and restart run one at a time, so overlapping calls (e.g. two quick
+// preset switches) can't leave two servers running
+let serverQueue: Promise<unknown> = Promise.resolve()
+
+function runExclusive<T>(task: () => Promise<T>): Promise<T> {
+    const result = serverQueue.then(task)
+    serverQueue = result.catch(() => {})
+    return result
+}
+
 /**
  * Get the path to the standalone server resources
  * In packaged app: resources/standalone
@@ -45,7 +57,11 @@ async function waitForServer(url: string, timeout = 30000): Promise<void> {
  * Start the Next.js standalone server using Electron's utilityProcess
  * This API is designed for running Node.js code in the background
  */
-export async function startNextServer(): Promise<string> {
+export function startNextServer(): Promise<string> {
+    return runExclusive(startServer)
+}
+
+async function startServer(): Promise<string> {
     const resourcePath = getResourcePath()
     const serverPath = path.join(resourcePath, "server.js")
 
@@ -73,6 +89,11 @@ export async function startNextServer(): Promise<string> {
         NODE_USE_ENV_PROXY: "1",
     }
 
+    // Keep requests to local model servers (e.g. Ollama) off the proxy
+    if (!process.env.NO_PROXY && !process.env.no_proxy) {
+        env.NO_PROXY = "localhost,127.0.0.1,[::1]"
+    }
+
     // Set cache directory to a writable location (user's app data folder)
     // This is necessary because the packaged app might be on a read-only volume
     if (app.isPackaged) {
@@ -96,28 +117,33 @@ export async function startNextServer(): Promise<string> {
 
     // Use Electron's utilityProcess API for running Node.js in background
     // This is the recommended way to run Node.js code in Electron
-    serverProcess = utilityProcess.fork(serverPath, [], {
+    const proc = utilityProcess.fork(serverPath, [], {
         cwd: resourcePath,
         env,
         stdio: "pipe",
     })
+    serverProcess = proc
 
-    serverProcess.stdout?.on("data", (data) => {
+    proc.stdout?.on("data", (data) => {
         console.log(`[Next.js] ${data.toString().trim()}`)
     })
 
-    serverProcess.stderr?.on("data", (data) => {
+    proc.stderr?.on("data", (data) => {
         console.error(`[Next.js Error] ${data.toString().trim()}`)
     })
 
-    serverProcess.on("exit", (code) => {
+    proc.on("exit", (code) => {
         console.log(`Next.js server exited with code ${code}`)
-        serverProcess = null
+        // An old server can exit after a new one started; keep the new one
+        if (serverProcess === proc) {
+            serverProcess = null
+        }
     })
 
     const url = getServerUrl()
     await waitForServer(url)
     console.log(`Next.js server started at ${url}`)
+    saveServerPort(port)
 
     return url
 }
@@ -126,39 +152,36 @@ export async function startNextServer(): Promise<string> {
  * Stop the Next.js server process and wait for it to exit
  */
 export async function stopNextServer(): Promise<void> {
-    if (serverProcess) {
-        console.log("Stopping Next.js server...")
+    const proc = serverProcess
+    if (!proc) {
+        return
+    }
+    console.log("Stopping Next.js server...")
+    serverProcess = null
 
-        // Create a promise that resolves when the process exits
-        const exitPromise = new Promise<void>((resolve) => {
-            const proc = serverProcess
-            if (!proc) {
-                resolve()
-                return
-            }
-
-            const onExit = () => {
-                resolve()
-            }
-
-            proc.once("exit", onExit)
-
-            // Timeout after 5 seconds
-            setTimeout(() => {
-                proc.removeListener("exit", onExit)
-                resolve()
-            }, 5000)
+    // Resolves true when the process exits, false after the timeout
+    const waitForExit = (ms: number) =>
+        new Promise<boolean>((resolve) => {
+            proc.once("exit", () => resolve(true))
+            setTimeout(() => resolve(false), ms)
         })
 
-        serverProcess.kill()
-        serverProcess = null
+    proc.kill()
 
-        // Wait for process to exit
-        await exitPromise
-
-        // Additional wait for OS to release port
-        await new Promise((resolve) => setTimeout(resolve, 500))
+    // Next.js waits for open requests (e.g. a streaming reply) before it
+    // exits, so force kill it if it is still running after 5 seconds
+    if (!(await waitForExit(5000)) && proc.pid) {
+        console.warn("Next.js server did not exit in time, force killing it")
+        try {
+            process.kill(proc.pid, "SIGKILL")
+        } catch (error) {
+            console.error("Failed to force kill Next.js server:", error)
+        }
+        await waitForExit(2000)
     }
+
+    // Additional wait for OS to release port
+    await new Promise((resolve) => setTimeout(resolve, 500))
 }
 
 /**
@@ -184,15 +207,19 @@ async function waitForServerStop(timeout = 5000): Promise<void> {
 /**
  * Restart the Next.js server with new environment variables
  */
-export async function restartNextServer(): Promise<string> {
-    console.log("Restarting Next.js server...")
+export function restartNextServer(): Promise<string> {
+    return runExclusive(async () => {
+        console.log("Restarting Next.js server...")
 
-    // Stop the current server and wait for it to exit
-    await stopNextServer()
+        // Stop the current server and wait for it to exit
+        await stopNextServer()
 
-    // Wait for the port to be released
-    await waitForServerStop()
+        // Wait for the port to be released
+        await waitForServerStop()
 
-    // Start the server again
-    return startNextServer()
+        // Start the server again, and follow it if it moved to another port
+        const url = await startServer()
+        setAppUrl(url)
+        return url
+    })
 }