@amd-gaia/agent-ui 0.25.0 → 0.25.1-rc.2

package/services/agent-process-manager.cjs

@@ -26,6 +26,7 @@ const path = require("path");
 const fs = require("fs");
 const os = require("os");
 const { EventEmitter } = require("events");
+const { killProcessTree, listDescendants } = require("./process-tree.cjs");
 
 // ── Constants ────────────────────────────────────────────────────────────
 
@@ -38,6 +39,9 @@ const MANIFEST_FILENAME = "agent-manifest.json";
 /** Graceful shutdown timeout before force kill (ms) */
 const SHUTDOWN_TIMEOUT = 5000;
 
+/** After the graceful shutdown, how long the tree gets between SIGTERM and SIGKILL (ms) */
+const TREE_KILL_GRACE = 2000;
+
 /** Health check interval (ms) — uses MCP "ping", not "initialize" */
 const HEALTH_CHECK_INTERVAL = 30000;
 
@@ -82,6 +86,7 @@ class AgentProcessManager extends EventEmitter {
    *   handlers proxy to that backend's `/api/agents/*` routes (the real install
    *   runtime), so without a resolver those handlers fail loudly rather than
    *   duplicating download/verify/uv logic in the main process (issue #1721).
+   *   killTree / listDescendants replace the process-tree helpers (tests).
    */
   constructor(mainWindow, options = {}) {
     super();
@@ -110,6 +115,12 @@ class AgentProcessManager extends EventEmitter {
      */
     this.processes = {};
 
+    this._killTree = options.killTree || killProcessTree;
+    this._listDescendants = options.listDescendants || listDescendants;
+
+    /** Set by stopAll(): GAIA is quitting, so nothing may start another agent. */
+    this._shuttingDown = false;
+
     /** Crash timestamps per agent for rate-limiting restart attempts */
     this._crashTimes = {};
 
@@ -130,6 +141,11 @@ class AgentProcessManager extends EventEmitter {
    * @returns {Promise<{ pid: number }>}
    */
   async startAgent(agentId) {
+    if (this._shuttingDown) {
+      throw new Error(
+        `Not starting agent "${agentId}": GAIA is quitting and has already stopped its agents.`
+      );
+    }
     if (this.processes[agentId]) {
       console.log(`[agent-mgr] Agent ${agentId} is already running (PID ${this.processes[agentId].process.pid})`);
       return { pid: this.processes[agentId].process.pid };
@@ -166,10 +182,18 @@ class AgentProcessManager extends EventEmitter {
       pendingRpc: {},
       healthTimer: null,
       stopping: false, // Set to true during intentional shutdown to suppress crash recovery
+      stopPromise: null, // The running stopAgent(), shared by duplicate calls
+      stdinError: null, // The error that broke stdin; nothing more can be written once set
     };
 
     this.processes[agentId] = entry;
 
+    // A write to a child that has died fails later, as an 'error' on the
+    // stream; without a listener that EPIPE crashes the whole app (#3498).
+    child.stdin.on("error", (err) => {
+      this._handleStdinError(agentId, child, err);
+    });
+
     // ── stdout: JSON-RPC message stream ──
     child.stdout.on("data", (data) => {
       this._handleStdout(agentId, data);
@@ -207,6 +231,7 @@ class AgentProcessManager extends EventEmitter {
   /**
    * Stop an agent gracefully using JSON-RPC shutdown protocol.
    * Cross-platform (works on Windows where SIGTERM = TerminateProcess).
+   * A second call while the first runs waits for that same stop.
    * @param {string} agentId
    * @returns {Promise<void>}
    */
@@ -217,23 +242,40 @@ class AgentProcessManager extends EventEmitter {
       return;
     }
 
-    // Guard against concurrent stopAgent() calls for the same agent
-    if (entry.stopping) {
-      console.log(`[agent-mgr] Agent ${agentId} is already being stopped — skipping duplicate`);
-      return;
+    if (entry.stopPromise) {
+      console.log(`[agent-mgr] Agent ${agentId} is already being stopped — waiting for that stop`);
+      return entry.stopPromise;
     }
 
     console.log(`[agent-mgr] Stopping agent ${agentId} (PID ${entry.process.pid})...`);
 
     // Mark as intentionally stopping — suppresses crash recovery in _handleProcessExit
     entry.stopping = true;
+    entry.stopPromise = this._stopAgent(agentId, entry);
+    return entry.stopPromise;
+  }
 
+  async _stopAgent(agentId, entry) {
     // Clear health check timer
     if (entry.healthTimer) {
       clearInterval(entry.healthTimer);
       entry.healthTimer = null;
     }
 
+    // Read the tree while the agent is alive: once it exits, its children
+    // are re-parented on Linux and macOS and can no longer be found from it.
+    let knownDescendants = [];
+    if (entry.process.exitCode === null && entry.process.signalCode === null) {
+      try {
+        ({ descendants: knownDescendants } = await this._listDescendants(entry.process.pid));
+      } catch (err) {
+        console.error(
+          `[agent-mgr] Could not list the processes agent ${agentId} started (${err.message}); ` +
+            "any it leaves behind will keep running."
+        );
+      }
+    }
+
     // Step 1: Send JSON-RPC shutdown request via stdin
     try {
       this._sendJsonRpcRaw(agentId, "shutdown", {});
@@ -247,17 +289,17 @@ class AgentProcessManager extends EventEmitter {
     // Step 2: Wait up to SHUTDOWN_TIMEOUT for clean exit
     const exited = await this._waitForExit(agentId, SHUTDOWN_TIMEOUT);
 
-    // Step 3: Force kill if still running
-    if (!exited && this.processes[agentId]) {
+    // Step 3: Stop the agent if it ignored the request, and anything it started either way.
+    if (!exited) {
       console.warn(
         `[agent-mgr] Agent ${agentId} did not exit within ${SHUTDOWN_TIMEOUT}ms, force killing...`
       );
-      try {
-        entry.process.kill(); // SIGKILL on Unix, TerminateProcess on Windows
-      } catch {
-        // Already dead
-      }
     }
+    await this._killTree(entry.process, {
+      knownDescendants,
+      graceMs: TREE_KILL_GRACE,
+      label: `agent ${agentId}`,
+    });
 
     // Note: _handleProcessExit may have already cleaned up if the process exited.
     // _cleanupProcess is idempotent, so calling it again is safe.
@@ -626,7 +668,13 @@ class AgentProcessManager extends EventEmitter {
 
       entry.pendingRpc[id] = { resolve, reject, timer };
 
-      this._sendJsonRpcRaw(agentId, method, params, id);
+      try {
+        this._sendJsonRpcRaw(agentId, method, params, id);
+      } catch (err) {
+        clearTimeout(timer);
+        delete entry.pendingRpc[id];
+        reject(err);
+      }
     });
   }
 
@@ -639,6 +687,7 @@ class AgentProcessManager extends EventEmitter {
     const agentConfigs = this.config.agents || {};
 
     for (const [agentId, agentCfg] of Object.entries(agentConfigs)) {
+      if (this._shuttingDown) return;
       if (agentCfg.autoStart && !this.processes[agentId]) {
         try {
           await this.startAgent(agentId);
@@ -656,13 +705,16 @@ class AgentProcessManager extends EventEmitter {
   }
 
   /**
-   * Stop all running agents gracefully.
+   * Stop all running agents gracefully. For quitting only: afterwards no
+   * agent can be started, so a pending auto-start or crash restart can't
+   * spawn one the app will never stop.
    */
   async stopAll() {
     const agentIds = Object.keys(this.processes);
     console.log(
       `[agent-mgr] Stopping all agents: ${agentIds.join(", ") || "(none)"}`
     );
+    this._shuttingDown = true;
     await Promise.all(agentIds.map((id) => this.stopAgent(id)));
   }
 
@@ -832,6 +884,7 @@ class AgentProcessManager extends EventEmitter {
     );
 
     setTimeout(async () => {
+      if (this._shuttingDown) return;
       try {
         await this.startAgent(agentId);
         console.log(`[agent-mgr] Agent ${agentId} restarted after crash`);
@@ -858,6 +911,11 @@ class AgentProcessManager extends EventEmitter {
     if (!entry || !entry.process.stdin || entry.process.stdin.destroyed) {
       throw new Error(`Cannot write to stdin of agent "${agentId}"`);
     }
+    if (entry.stdinError) {
+      throw new Error(
+        `Cannot write to stdin of agent "${agentId}": the pipe broke earlier (${entry.stdinError.message})`
+      );
+    }
 
     const msg = {
       jsonrpc: "2.0",
@@ -870,6 +928,36 @@ class AgentProcessManager extends EventEmitter {
     entry.process.stdin.write(payload);
   }
 
+  /**
+   * The agent's stdin failed — almost always EPIPE because the process is
+   * gone. Fail its pending calls now instead of letting them time out, and
+   * make sure the death is reported: a child that only closed its stdin is
+   * unusable, so it is stopped and its exit goes through the crash path.
+   */
+  _handleStdinError(agentId, child, err) {
+    const entry = this.processes[agentId];
+    const current = entry && entry.process === child ? entry : null;
+    const exited = child.exitCode !== null || child.signalCode !== null;
+    console.error(
+      `[agent-mgr] stdin of agent ${agentId} (PID ${child.pid}) failed: ${err.code || "error"} ${err.message}` +
+        (exited ? " — the agent had already exited" : "")
+    );
+    if (!current) return;
+    current.stdinError = err;
+
+    for (const [rpcId, pending] of Object.entries(current.pendingRpc)) {
+      clearTimeout(pending.timer);
+      delete current.pendingRpc[rpcId];
+      pending.reject(new Error(`Agent "${agentId}" stopped reading its input (${err.code || err.message})`));
+    }
+
+    if (exited || current.stopping) return;
+    console.error(`[agent-mgr] Agent ${agentId} can no longer receive requests — stopping it`);
+    this._killTree(child, { graceMs: TREE_KILL_GRACE, label: `agent ${agentId}` }).catch((killErr) => {
+      console.error(`[agent-mgr] Could not stop agent ${agentId} after its stdin broke: ${killErr.message}`);
+    });
+  }
+
   // ── Private: Health check ────────────────────────────────────────────
 
   async _healthCheck(agentId) {

package/services/auto-updater.cjs

@@ -106,6 +106,8 @@ const state = {
 };
 
 let mainWindowRef = null;
+/** Asks before an update restart would cut off running work (set by init). */
+let confirmRestartRef = null;
 let checkInProgress = false;
 let scheduledTimeout = null;
 let initialCheckTimeout = null;
@@ -616,13 +618,25 @@ function wireAutoUpdaterEvents() {
         }
       );
       if (choice && choice.response === 0) {
+        // quitAndInstall starts the installer at once, so ask about running
+        // work here; the quit that follows doesn't ask again.
+        if (!(await confirmRestartRef())) {
+          log("info", "Restart put off: work is still running — will install on next quit");
+          return;
+        }
         log("info", "User chose to restart — calling quitAndInstall");
         autoUpdaterRef.quitAndInstall(false, true);
       } else {
         log("info", "User deferred restart — will install on next quit");
       }
     } catch (err) {
-      log("error", "Failed to show restart dialog:", err && err.message);
+      const message = (err && err.message) || String(err);
+      log("error", "Failed to show restart dialog:", message);
+      electronApi.dialog.showErrorBox(
+        "GAIA update",
+        `GAIA couldn't finish asking about the update restart: ${message}\n\n` +
+          "The update installs the next time you quit GAIA."
+      );
     }
   });
 
@@ -689,9 +703,19 @@ function unregisterIpcHandlers() {
  * continues, and this function itself never throws.
  *
  * @param {Electron.BrowserWindow | null} mainWindow
+ * @param {object} options
+ * @param {() => Promise<boolean>} options.confirmRestart - Whether "Restart now"
+ *   may go ahead; asked before the installer starts. Required: without it an
+ *   update restart would silently cut off a running answer.
  */
-function init(mainWindow) {
+function init(mainWindow, options = {}) {
+  if (typeof options.confirmRestart !== "function") {
+    throw new TypeError(
+      "auto-updater init needs options.confirmRestart, so Restart now can ask before it stops running work"
+    );
+  }
   mainWindowRef = mainWindow || null;
+  confirmRestartRef = options.confirmRestart;
 
   // Disabled path — short-circuit BEFORE touching any Electron APIs so
   // this works in plain Node tests where require('electron') returns a

package/services/backend-installer-progress-dialog.cjs

@@ -90,13 +90,13 @@ function buildProgressHtml({ logPath }) {
    * src/styles/index.css, so the dark theme's role values are mirrored
    * here. Keep them in step with that file; nothing below names a hex. */
   :root {
-    --bg-primary: #17161C;
-    --bg-tertiary: #2A2831;
-    --border: #3A3842;
-    --text-primary: #F0EDE7;
-    --text-secondary: #AAA5B0;
-    --text-muted: #8C8794;
-    --accent-fill: #9A4930;
+    --bg-primary: #1A1917;
+    --bg-tertiary: #2C2B27;
+    --border: #4A4740;
+    --text-primary: #EFECE6;
+    --text-secondary: #B3ADA5;
+    --text-muted: #958F87;
+    --accent-solid: #D4B47E;
   }
   html, body {
     margin: 0;
@@ -152,7 +152,7 @@ function buildProgressHtml({ logPath }) {
   }
   .fill {
     height: 100%;
-    background: var(--accent-fill);
+    background: var(--accent-solid);
     border-radius: 9999px;
     transition: width 300ms ease-out;
     width: 0%;
@@ -268,7 +268,7 @@ function createProgressWindow() {
     frame: false,
     transparent: false,
     show: false,
-    backgroundColor: "#17161C", // --bg-primary, dark theme (see the :root block above)
+    backgroundColor: "#1A1917", // --bg-primary, dark theme (see the :root block above)
     title: "Installing GAIA",
     webPreferences: {
       nodeIntegration: false,

package/services/keep-awake.cjs

@@ -0,0 +1,52 @@
+// Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+/**
+ * Keep the PC from idle-sleeping while GAIA works (#5226).
+ *
+ * The renderer decides when (a turn is running, the setting is on, and the
+ * battery policy allows it) and calls `power:keep-awake`; this service owns
+ * the one powerSaveBlocker. The display may still turn off — only system
+ * sleep is held off.
+ */
+
+const { ipcMain, powerSaveBlocker } = require("electron");
+
+class KeepAwake {
+  constructor() {
+    /** @type {number | null} */
+    this._blockerId = null;
+    ipcMain.handle("power:keep-awake", (_event, on) => this.set(on));
+  }
+
+  /**
+   * @param {boolean} on
+   * @returns {boolean} whether sleep is now being held off.
+   */
+  set(on) {
+    if (typeof on !== "boolean") {
+      throw new TypeError(`power:keep-awake expects a boolean, got ${typeof on}`);
+    }
+    if (on && this._blockerId === null) {
+      this._blockerId = powerSaveBlocker.start("prevent-app-suspension");
+      console.log("[power] Holding off idle sleep while GAIA works");
+    } else if (!on && this._blockerId !== null) {
+      powerSaveBlocker.stop(this._blockerId);
+      this._blockerId = null;
+      console.log("[power] Idle sleep allowed again");
+    }
+    return this.active;
+  }
+
+  /** @returns {boolean} */
+  get active() {
+    return this._blockerId !== null && powerSaveBlocker.isStarted(this._blockerId);
+  }
+
+  destroy() {
+    this.set(false);
+    ipcMain.removeHandler("power:keep-awake");
+  }
+}
+
+module.exports = KeepAwake;

package/services/notification-service.cjs

@@ -314,6 +314,55 @@ class NotificationService extends EventEmitter {
     this._sendToRenderer("tray:navigate", `notification:${notif.id}`);
   }
 
+  // ── Chat alerts ──────────────────────────────────────────────────────
+
+  /**
+   * Show an OS banner for a chat event. Clicking it focuses the window and
+   * opens that chat. Silent: the renderer plays the user's chosen sound.
+   *
+   * @param {{title: string, body: string, sessionId: string}} payload
+   * @returns {boolean} false when the OS has no notification support.
+   */
+  showChatBanner(payload) {
+    if (!payload || typeof payload.title !== "string" || typeof payload.sessionId !== "string") {
+      throw new TypeError("notification:show expects {title, body, sessionId}");
+    }
+    if (!Notification.isSupported()) {
+      console.warn("[notif] OS notifications not supported on this platform");
+      return false;
+    }
+    const osNotif = new Notification({
+      title: payload.title,
+      body: typeof payload.body === "string" ? payload.body : "",
+      icon: path.join(__dirname, "..", "assets", "icon.png"),
+      silent: true,
+    });
+    osNotif.on("click", () => {
+      if (!this.mainWindow || this.mainWindow.isDestroyed()) return;
+      if (this.mainWindow.isMinimized()) this.mainWindow.restore();
+      this.mainWindow.show();
+      this.mainWindow.focus();
+      this._sendToRenderer("tray:navigate", `session:${payload.sessionId}`);
+    });
+    osNotif.show();
+    return true;
+  }
+
+  /**
+   * Flash the taskbar button until the window is focused. A no-op while
+   * it already has focus.
+   * @returns {boolean} whether it flashed.
+   */
+  flashWindow() {
+    const win = this.mainWindow;
+    if (!win || win.isDestroyed() || win.isFocused()) return false;
+    win.flashFrame(true);
+    win.once("focus", () => {
+      if (!win.isDestroyed()) win.flashFrame(false);
+    });
+    return true;
+  }
+
   // ── Private: Tray badge ──────────────────────────────────────────────
 
   _updateTrayBadge() {
@@ -423,6 +472,19 @@ class NotificationService extends EventEmitter {
         this._respondToPermission(notifId, action, remember);
       }
     );
+
+    // Chat alerts (#5226): the renderer decides what fires per the user's
+    // settings; main owns the OS surfaces it can't reach.
+    ipcMain.handle("notification:show", (_event, payload) =>
+      this.showChatBanner(payload)
+    );
+    ipcMain.handle("notification:flash", () => this.flashWindow());
+    ipcMain.handle("notification:attention", (_event, count) => {
+      if (!this.trayManager) {
+        throw new Error("No tray to badge: the tray manager was not created");
+      }
+      this.trayManager.setAttentionCount(count);
+    });
   }
 
   // ── Private: Helpers ─────────────────────────────────────────────────

package/services/port-manager.cjs

@@ -22,6 +22,7 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { execFileSync } = require("child_process");
+const { killProcessTree } = require("./process-tree.cjs");
 
 /**
  * Resolve the GAIA home directory lazily so tests can point it elsewhere
@@ -54,86 +55,29 @@ function findFreePort() {
 }
 
 /**
- * Terminate a spawned backend: SIGTERM, wait up to 3 s, then SIGKILL.
+ * Terminate a spawned backend and everything it started: SIGTERM the tree,
+ * wait up to 3 s, then SIGKILL what is left. Without the tree walk, killing
+ * the uv `gaia.exe` launcher on Windows left its Python running.
  * Accepts either a ChildProcess reference (preferred — lets us
  * short-circuit via `exitCode` so PID reuse can never hit us) or a raw
- * pid (useful for tests). Safe to call with nullish.
+ * pid (the orphan cleanup and tests). Safe to call with nullish.
  */
 async function killBackend(procOrPid, logger) {
   const log = (logger && logger.log) || console.log;
   const logError = (logger && logger.error) || console.error;
-
   if (!procOrPid) return;
-
-  // Distinguish ChildProcess vs raw pid. A ChildProcess has both .pid
-  // and .exitCode/.signalCode; typeof === "object" is enough.
-  const isChildProcess = typeof procOrPid === "object";
-  const proc = isChildProcess ? procOrPid : null;
-  const pid = isChildProcess ? procOrPid.pid : procOrPid;
-
-  if (!pid) return;
-
-  // If we have the ChildProcess handle, trust it — the exitCode is set
-  // synchronously by Node's child_process before any pid reuse could
-  // happen, so this closes the PID-reuse TOCTOU that a pid-only API has.
+  const proc = typeof procOrPid === "object" ? procOrPid : null;
   if (proc && (proc.exitCode !== null || proc.signalCode !== null)) {
-    log(`[port-manager] child pid ${pid} already exited (exitCode=${proc.exitCode} signal=${proc.signalCode})`);
-    return;
-  }
-
-  // Is the process still alive? kill(pid, 0) throws ESRCH if not.
-  // Only relied on when the caller passed a raw pid (tests); callers
-  // with a ChildProcess were already short-circuited above.
-  const alive = (p) => {
-    try {
-      process.kill(p, 0);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-
-  if (!alive(pid)) {
-    log(`[port-manager] pid ${pid} already gone`);
-    return;
-  }
-
-  try {
-    process.kill(pid, "SIGTERM");
-    log(`[port-manager] SIGTERM sent to pid ${pid}`);
-  } catch (err) {
-    logError(`[port-manager] SIGTERM failed for pid ${pid}: ${err.message}`);
+    log(`[port-manager] child pid ${proc.pid} already exited (exitCode=${proc.exitCode} signal=${proc.signalCode})`);
     return;
   }
-
-  const deadline = Date.now() + 3000;
-  while (Date.now() < deadline) {
-    if (!alive(pid)) {
-      log(`[port-manager] pid ${pid} exited after SIGTERM`);
-      return;
-    }
-    await new Promise((r) => setTimeout(r, 100));
-  }
-
-  try {
-    process.kill(pid, "SIGKILL");
-    log(`[port-manager] SIGKILL sent to pid ${pid} (did not exit on SIGTERM)`);
-  } catch (err) {
-    logError(`[port-manager] SIGKILL failed for pid ${pid}: ${err.message}`);
-    return;
-  }
-
-  // Poll until the kernel reaps the process so callers can safely rebind
-  // the port immediately after we return. 1 s cap at 50 ms intervals —
-  // SIGKILL is synchronous in the kernel but reaping the zombie can lag.
-  const killDeadline = Date.now() + 1000;
-  while (Date.now() < killDeadline) {
-    if (!alive(pid)) return;
-    await new Promise((r) => setTimeout(r, 50));
-  }
-  logError(
-    `[port-manager] pid ${pid} still alive 1s after SIGKILL — orphan risk`,
-  );
+  await killProcessTree(procOrPid, {
+    graceMs: 3000,
+    forceWaitMs: 1000,
+    log,
+    logError,
+    label: "backend",
+  });
 }
 
 /**