fix(electron): address round-6 review feedback

- Add main-safety-net.cjs and services/*.cjs to Jest collectCoverageFrom
  so the 13 hermetic tests count toward the 50% coverage threshold
- Move process.exit(1) to end of safety-net catch block so _fatalHandler
  fallback is reachable before the process terminates; fix operator
  precedence to String((err && err.stack) || err) in both dialog calls
- Clean up instance 1 listeners before installing instance 2 in test 6
  (counter increment) so the test does not rely on _inFatalHandler being
  stuck true due to mocked process.exit
- Add test 13 asserting installSafetyNet returns { fatal } -- guards
  against a refactor that drops the return value silently no-oping the
  app.whenReady().catch(_fatalHandler) call in main.cjs
- Replace _gaiaLogTeeBound stream mutation with a WeakSet so installLogTee
  idempotency does not mutate the caller-supplied stream object

Author: itomek

src/gaia/apps/webui/main-safety-net.cjs

@@ -149,12 +149,13 @@ function installSafetyNet({ logPath, dialogModule, appModule, homedirFn }) {
  * @param {object} opts
  * @param {EventEmitter} opts.stream   - The writable stream to guard.
  * @param {string}       opts.logPath  - Path for fallback error logging.
- * @note Must be called at most once per stream instance. Calling it twice
- *       registers a second 'error' listener and doubles log entries per error.
+ * @note Must be called at most once per stream instance. The internal WeakSet
+ *       guard enforces this — a second call on the same stream is a no-op.
  */
+const _teedStreams = new WeakSet();
 function installLogTee({ stream, logPath }) {
-  if (stream._gaiaLogTeeBound) return;
-  stream._gaiaLogTeeBound = true;
+  if (_teedStreams.has(stream)) return;
+  _teedStreams.add(stream);
   stream.on("error", (err) => {
     const detail = (err && err.message) || (err && err.stack) || String(err);
     appendLog(logPath, `[${new Date().toISOString()}] STREAM_ERROR ${detail}`);

src/gaia/apps/webui/main.cjs

@@ -46,17 +46,16 @@ try {
   }));
 } catch (err) {
   try { process.stderr.write(`[main] safety-net load failed: ${err.message}\n`); } catch { }
-  try { dialog.showErrorBox("GAIA failed to start", String(err && err.stack || err)); } catch { }
-  // Inline fallback so any later .catch(_fatalHandler) still has something callable
-  // if app.exit(1) hasn't taken effect yet (app.exit schedules, not instant).
+  try { dialog.showErrorBox("GAIA failed to start", String((err && err.stack) || err)); } catch { }
+  // Inline fallback: app.whenReady().catch(_fatalHandler) at line ~800 still
+  // has something callable in the narrow window before process.exit() below
+  // terminates the process.
   _fatalHandler = (e) => {
-    try { dialog.showErrorBox("GAIA crashed", String(e && e.stack || e)); } catch { }
+    try { dialog.showErrorBox("GAIA crashed", String((e && e.stack) || e)); } catch { }
     try { process.exit(1); } catch { }
   };
-  app.exit(1);
-  // Stop loading service modules synchronously — app.exit() is scheduled,
-  // not instant, so execution would otherwise continue into the requires
-  // below with no uncaughtException handler installed.
+  // Synchronous exit stops service module requires from running with no
+  // uncaughtException handler — app.exit() is scheduled, not instant.
   process.exit(1);
 }
 

tests/electron/package.json

@@ -14,6 +14,8 @@
     "coverageDirectory": "coverage",
     "collectCoverageFrom": [
       "../../src/gaia/electron/**/*.js",
+      "../../src/gaia/apps/webui/*.cjs",
+      "../../src/gaia/apps/webui/services/*.cjs",
       "../../src/gaia/apps/**/webui/src/**/*.js",
       "!../../src/gaia/apps/**/webui/src/renderer/**/*.js",
       "!**/node_modules/**",

tests/electron/test_main_error_handling.js

@@ -196,10 +196,11 @@ describe("installSafetyNet", () => {
     const after1 = JSON.parse(fs.readFileSync(counterPath, "utf8"));
     expect(after1.count).toBe(1);
 
-    // Each installSafetyNet() call creates a fresh closure with its own
-    // _inFatalHandler flag. The resetModules()+re-require here creates a
-    // second independent instance so the second fatal() call is not blocked
-    // by the first instance's re-entry guard.
+    // Remove instance 1's listeners so instance 2's fatal() runs cleanly
+    // without relying on instance 1's _inFatalHandler being stuck true.
+    addedListeners.forEach(({ event, handler }) => process.removeListener(event, handler));
+    addedListeners.length = 0;
+
     jest.resetModules();
     const { installSafetyNet: installSafetyNet2 } = require(SAFETY_NET_PATH);
     installSafetyNet2({
@@ -352,4 +353,19 @@ describe("installSafetyNet", () => {
 
     exitSpy.mockRestore();
   });
+
+  // ── Test 13: installSafetyNet returns { fatal } ────────────────────────────
+  // main.cjs destructures { fatal: _fatalHandler } and routes
+  // app.whenReady().catch() through it. If a refactor stops returning fatal,
+  // _fatalHandler becomes undefined and the catch silently no-ops.
+
+  test("returns { fatal } function so main.cjs can route .catch() through it", () => {
+    const { installSafetyNet } = require(SAFETY_NET_PATH);
+    const result = installSafetyNet({
+      logPath,
+      dialogModule: mockDialog(),
+      appModule: mockApp(false),
+    });
+    expect(typeof result.fatal).toBe("function");
+  });
 });