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

package/services/process-tree.cjs

@@ -0,0 +1,328 @@
+// Copyright(C) 2026 Advanced Micro Devices, Inc. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+/**
+ * Stop a child process together with everything it started.
+ *
+ * Killing only the direct child leaves its own children running after the app
+ * is gone: the uv `gaia.exe` launcher's Python, a PyInstaller bootloader's
+ * server, or the MCP servers and shell commands an agent spawned. They keep
+ * ports and file handles, and the next launch trips over them.
+ *
+ * The tree is read from the OS process table (`ps` on Linux and macOS,
+ * Win32_Process on Windows), walked by parent pid, and every member is
+ * signalled. GAIA's shared servers (the daemon and Lemonade) are left alone:
+ * every GAIA client shares them, they outlive the app on purpose, and the
+ * daemon unloads its models itself once the app is gone (GAIA_APP_PID).
+ */
+
+"use strict";
+
+const childProcess = require("child_process");
+
+const DEFAULT_GRACE_MS = 3000;
+const DEFAULT_FORCE_WAIT_MS = 1000;
+// PowerShell's CIM query takes about a second on an idle PC and several on a
+// loaded one; timing out strands every process the agent started. `ps` is fast.
+const WINDOWS_LIST_TIMEOUT_MS = 20000;
+const POSIX_LIST_TIMEOUT_MS = 5000;
+const POLL_MS = 50;
+
+// The daemon by its module or CLI verb; Lemonade by its executable's name,
+// so a tool that merely mentions Lemonade (--lemonade-url) is still stopped.
+const SHARED_SERVER_PATTERN =
+  /(?:-m\s+gaia\.daemon\b)|(?:\bgaia(?:\.exe)?["']?\s+daemon\b)|(?:^|[\\/"'\s])(?:lemonade|lemonade-server|lemonadeserver|lemonade-tray|lemond)(?:\.exe)?(?=["'\s]|$)/i;
+
+/** Longest one read of the process table may take on `platform` (ms). */
+function listTimeoutMs(platform = process.platform) {
+  return platform === "win32" ? WINDOWS_LIST_TIMEOUT_MS : POSIX_LIST_TIMEOUT_MS;
+}
+
+/**
+ * Longest killProcessTree can take (ms): one table read, the grace period,
+ * a second read outside Windows, and the SIGKILL wait.
+ */
+function worstCaseKillMs({
+  platform = process.platform,
+  graceMs = DEFAULT_GRACE_MS,
+  forceWaitMs = DEFAULT_FORCE_WAIT_MS,
+} = {}) {
+  const reads = platform === "win32" ? 1 : 2;
+  return reads * listTimeoutMs(platform) + graceMs + forceWaitMs;
+}
+
+/** True for a command line that belongs to a server shared by every GAIA client. */
+function isSharedServer(command) {
+  return SHARED_SERVER_PATTERN.test(command || "");
+}
+
+// Linux and macOS re-parent an orphan, so its ppid is always current.
+function parsePosixTable(stdout) {
+  const rows = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const m = /^\s*(\d+)\s+(\d+)\s?(.*)$/.exec(line);
+    if (m) rows.push({ pid: Number(m[1]), ppid: Number(m[2]), command: m[3].trim(), started: null });
+  }
+  return rows;
+}
+
+// Windows never updates ParentProcessId when the parent dies, and reuses
+// pids, so each row carries its creation time (FILETIME) for the walk to
+// reject a "child" older than the parent it claims.
+function parseWindowsTable(stdout) {
+  const rows = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const parts = line.split("\t");
+    if (parts.length < 3 || !/^\d+$/.test(parts[0]) || !/^\d+$/.test(parts[1])) continue;
+    rows.push({
+      pid: Number(parts[0]),
+      ppid: Number(parts[1]),
+      started: /^\d+$/.test(parts[2]) ? BigInt(parts[2]) : null,
+      command: parts.slice(3).join("\t").trim(),
+    });
+  }
+  return rows;
+}
+
+/**
+ * Read the OS process table as `[{ pid, ppid, command }]`.
+ * Rejects with what failed and which command ran; never returns an empty
+ * table in place of an error.
+ */
+function listProcesses({ platform = process.platform, execFile = childProcess.execFile } = {}) {
+  const [cmd, args, parse] =
+    platform === "win32"
+      ? [
+          "powershell.exe",
+          [
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            "Get-CimInstance Win32_Process | ForEach-Object { \"$($_.ProcessId)`t$($_.ParentProcessId)`t$(if ($_.CreationDate) { $_.CreationDate.ToFileTimeUtc() })`t$($_.CommandLine)\" }",
+          ],
+          parseWindowsTable,
+        ]
+      : ["ps", ["-A", "-ww", "-o", "pid=", "-o", "ppid=", "-o", "command="], parsePosixTable];
+  return new Promise((resolve, reject) => {
+    execFile(
+      cmd,
+      args,
+      { windowsHide: true, timeout: listTimeoutMs(platform), maxBuffer: 32 * 1024 * 1024 },
+      (err, stdout) => {
+        if (err) {
+          reject(new Error(`could not read the process table with ${cmd}: ${err.message}`, { cause: err }));
+          return;
+        }
+        resolve(parse(String(stdout)));
+      }
+    );
+  });
+}
+
+/**
+ * Every descendant of `rootPid`, parents before children, skipping shared
+ * servers and anything they started.
+ * @returns {{ descendants: {pid:number, command:string}[], skipped: {pid:number, command:string}[] }}
+ */
+function descendantsFromTable(table, rootPid) {
+  const byPid = new Map(table.map((r) => [r.pid, r]));
+  const children = new Map();
+  for (const row of table) {
+    if (row.pid === row.ppid) continue;
+    if (!children.has(row.ppid)) children.set(row.ppid, []);
+    children.get(row.ppid).push(row);
+  }
+  const descendants = [];
+  const skipped = [];
+  const seen = new Set([rootPid]);
+  const queue = [rootPid];
+  while (queue.length) {
+    const parent = queue.shift();
+    const parentRow = byPid.get(parent);
+    for (const row of children.get(parent) || []) {
+      if (seen.has(row.pid)) continue;
+      // Older than its "parent": the real parent died and its pid was reused.
+      if (parentRow && parentRow.started != null && row.started != null && row.started < parentRow.started) {
+        continue;
+      }
+      seen.add(row.pid);
+      if (isSharedServer(row.command)) {
+        skipped.push({ pid: row.pid, command: row.command });
+        continue;
+      }
+      descendants.push({ pid: row.pid, command: row.command });
+      queue.push(row.pid);
+    }
+  }
+  return { descendants, skipped };
+}
+
+/** Snapshot the descendants of a live process (see descendantsFromTable). */
+async function listDescendants(rootPid, opts = {}) {
+  const table = await (opts.listProcesses || listProcesses)(opts);
+  return descendantsFromTable(table, rootPid);
+}
+
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM: it exists but belongs to someone else.
+    return err.code === "EPERM";
+  }
+}
+
+function rootAlive(proc, pid) {
+  if (proc) return proc.exitCode === null && proc.signalCode === null;
+  return pidAlive(pid);
+}
+
+/**
+ * Signal the root and every descendant, wait up to `graceMs`, then SIGKILL
+ * whatever is left — including anything the tree started in the meantime —
+ * and wait up to `forceWaitMs` for it to go.
+ *
+ * On Windows every signal is TerminateProcess, so the grace period only
+ * matters for processes that are already exiting.
+ *
+ * @param {import('child_process').ChildProcess|number} target
+ *   Prefer the ChildProcess: its exitCode is set before the pid can be
+ *   reused, so a finished child is never signalled.
+ * @param {object} [opts]
+ * @param {{pid:number, command:string}[]} [opts.knownDescendants]
+ *   Descendants snapshotted earlier, while the root was still alive. Needed
+ *   on Linux and macOS when the root may already have exited: its children
+ *   are then re-parented and can no longer be found from it. Each is killed
+ *   only while its command line still matches, so a reused pid is spared.
+ * @returns {Promise<{ killed: number[], survivors: number[] }>}
+ */
+async function killProcessTree(target, opts = {}) {
+  const {
+    graceMs = DEFAULT_GRACE_MS,
+    forceWaitMs = DEFAULT_FORCE_WAIT_MS,
+    knownDescendants = [],
+    log = console.log,
+    logError = console.error,
+    label = "process",
+    platform = process.platform,
+  } = opts;
+  const proc = target && typeof target === "object" ? target : null;
+  const pid = proc ? proc.pid : target;
+  if (!pid) return { killed: [], survivors: [] };
+
+  const readTable = () => (opts.listProcesses || listProcesses)(opts);
+
+  // pid -> command, for every non-root member we intend to stop.
+  const members = new Map();
+  const absorb = (table) => {
+    const live = new Map(table.map((r) => [r.pid, r.command]));
+    // A member that exited, or whose pid now runs something else, is no
+    // longer ours to signal.
+    for (const [memberPid, command] of [...members]) {
+      if (live.get(memberPid) !== command) members.delete(memberPid);
+    }
+    for (const d of knownDescendants) {
+      if (live.has(d.pid) && live.get(d.pid) === d.command) members.set(d.pid, d.command);
+    }
+    if (live.has(pid) && rootAlive(proc, pid)) {
+      for (const d of descendantsFromTable(table, pid).descendants) members.set(d.pid, d.command);
+    }
+    // Children of members that outlived their parent's handle.
+    for (const memberPid of [...members.keys()]) {
+      for (const d of descendantsFromTable(table, memberPid).descendants) members.set(d.pid, d.command);
+    }
+  };
+
+  let tableError = null;
+  try {
+    absorb(await readTable());
+  } catch (err) {
+    tableError = err;
+    logError(
+      `[process-tree] ${label} ${pid}: ${err.message} — only the ${label} itself will be stopped; ` +
+        "any process it started may keep running. Check them with Task Manager or `ps`."
+    );
+  }
+
+  const signal = (p, sig) => {
+    try {
+      if (p === pid && proc) {
+        if (rootAlive(proc, pid)) proc.kill(sig);
+      } else {
+        process.kill(p, sig);
+      }
+      return true;
+    } catch (err) {
+      if (err.code !== "ESRCH") {
+        logError(`[process-tree] ${sig} to pid ${p} (${label} ${pid}) failed: ${err.message}`);
+      }
+      return false;
+    }
+  };
+  const alive = (p) => (p === pid ? rootAlive(proc, pid) : pidAlive(p));
+  const waitAllGone = async (pids, ms) => {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+      if (!pids.some(alive)) return true;
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+    return !pids.some(alive);
+  };
+
+  const all = () => [pid, ...members.keys()];
+  const killed = [];
+  for (const p of all()) {
+    if (alive(p) && signal(p, "SIGTERM")) killed.push(p);
+  }
+  if (killed.length === 0) return { killed, survivors: [] };
+  log(`[process-tree] SIGTERM sent to ${label} ${pid} and ${killed.length - (killed.includes(pid) ? 1 : 0)} descendant(s)`);
+
+  if (await waitAllGone(all(), graceMs)) return { killed, survivors: [] };
+
+  if (platform === "win32") {
+    // SIGTERM was already TerminateProcess, so a member still listed is one
+    // that could not be ended or a pid already reused: only the root, through
+    // its handle, is worth a second try. Skipping the re-read also keeps a
+    // slow PowerShell from eating the quit's time limit.
+    members.clear();
+  } else if (!tableError) {
+    try {
+      absorb(await readTable());
+    } catch (err) {
+      // Without a fresh table a member's pid may already belong to a stranger.
+      members.clear();
+      logError(
+        `[process-tree] ${label} ${pid}: re-reading the tree before SIGKILL failed (${err.message}); ` +
+          `only the ${label} itself gets SIGKILL — any process it started may keep running.`
+      );
+    }
+  }
+  const stubborn = all().filter(alive);
+  for (const p of stubborn) {
+    if (signal(p, "SIGKILL") && !killed.includes(p)) killed.push(p);
+  }
+  log(`[process-tree] SIGKILL sent to ${stubborn.length} process(es) of ${label} ${pid} that ignored SIGTERM`);
+
+  await waitAllGone(stubborn, forceWaitMs);
+  const survivors = stubborn.filter(alive);
+  if (survivors.length) {
+    logError(
+      `[process-tree] ${label} ${pid}: pid(s) ${survivors.join(", ")} still running ${forceWaitMs} ms after SIGKILL — ` +
+        "end them with Task Manager or `kill -9` before relaunching GAIA."
+    );
+  }
+  return { killed, survivors };
+}
+
+module.exports = {
+  listTimeoutMs,
+  worstCaseKillMs,
+  killProcessTree,
+  listDescendants,
+  listProcesses,
+  descendantsFromTable,
+  isSharedServer,
+  parsePosixTable,
+  parseWindowsTable,
+};

package/services/quit-cleanup.cjs

@@ -0,0 +1,86 @@
+// Copyright(C) 2026 Advanced Micro Devices, Inc. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+/**
+ * Run the app's async cleanup exactly once on quit, and never let it hold
+ * the quit forever.
+ *
+ * Electron does not await before-quit/will-quit handlers, so will-quit
+ * cancels the quit, runs the cleanup, and quits again. A second quit while
+ * the cleanup runs (tray Quit then Cmd+Q, or a fatal error mid-quit) must
+ * wait for that same cleanup: starting another one let the second finish
+ * first and end the app while the first was still stopping the backend.
+ */
+
+"use strict";
+
+/**
+ * Longest the quit waits for cleanup before going ahead without it (ms).
+ * Covers the slowest agent stop: two 20 s Windows process-table reads, the
+ * agent's shutdown wait and the kill grace.
+ */
+const CLEANUP_TIMEOUT_MS = 50000;
+
+/**
+ * @param {object} deps
+ * @param {Electron.App} deps.app
+ * @param {() => Promise<void>} deps.cleanup
+ * @param {number} [deps.timeoutMs]
+ * @param {{log: Function, error: Function}} [deps.logger]
+ * @returns {{ readonly done: boolean, readonly running: Promise<void>|null }}
+ */
+function installQuitCleanup({ app, cleanup, timeoutMs = CLEANUP_TIMEOUT_MS, logger = console }) {
+  let done = false;
+  let running = null;
+
+  app.on("will-quit", (event) => {
+    if (done) return;
+    event.preventDefault();
+    if (running) {
+      logger.log("[main] will-quit: cleanup already running; quitting when it finishes");
+      return;
+    }
+    logger.log("[main] will-quit: performing async cleanup...");
+
+    let timer = null;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        logger.error(
+          `[main] Cleanup did not finish within ${timeoutMs} ms; quitting anyway. ` +
+            "A backend or agent process may still be running — check Task Manager or `ps`."
+        );
+        resolve();
+      }, timeoutMs);
+    });
+
+    running = Promise.race([
+      Promise.resolve()
+        .then(cleanup)
+        .catch((err) => {
+          logger.error("[main] Cleanup error:", (err && err.stack) || err);
+        }),
+      deadline,
+    ])
+      // Re-quit on a later task: Electron drops a quit() that arrives while it
+      // is still unwinding the will-quit it just prevented, which is what an
+      // instant cleanup (no backend left to stop) used to hit.
+      .then(() => new Promise((resolve) => setImmediate(resolve)))
+      .then(() => {
+        clearTimeout(timer);
+        done = true;
+        logger.log("[main] Cleanup complete, quitting...");
+        app.quit();
+      });
+  });
+
+  return {
+    get done() {
+      return done;
+    },
+    get running() {
+      return running;
+    },
+  };
+}
+
+module.exports = { installQuitCleanup, CLEANUP_TIMEOUT_MS };

package/services/quit-guard.cjs

@@ -0,0 +1,242 @@
+// Copyright(C) 2026 Advanced Micro Devices, Inc. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+/**
+ * Ask before quitting while an answer is being written or a document is
+ * being indexed: quitting stops both, and the answer is lost.
+ *
+ * The backend is asked at quit time (`GET /api/system/work-in-progress`),
+ * so nothing polls while GAIA is idle.
+ */
+
+const CHECK_TIMEOUT_MS = 3000;
+// After the quit question fails, how long a second quit goes through without it.
+const QUIT_ANYWAY_MS = 60_000;
+
+/** Read JSON from the GAIA service; throws an error that says what failed. */
+async function backendJson(
+  port,
+  route,
+  { method = "GET", body, timeoutMs = CHECK_TIMEOUT_MS, fetchImpl = fetch } = {}
+) {
+  const url = `http://127.0.0.1:${port}${route}`;
+  let resp;
+  try {
+    const headers = { "X-Gaia-UI": "1" };
+    // The service refuses a state-changing request without X-Gaia-UI (ui/security.py).
+    if (body !== undefined) headers["Content-Type"] = "application/json";
+    resp = await fetchImpl(url, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (err) {
+    throw new Error(`the GAIA service at ${url} did not answer (${err.message})`, { cause: err });
+  }
+  let reply = null;
+  try {
+    reply = await resp.json();
+  } catch (err) {
+    throw new Error(`the GAIA service sent an unreadable reply from ${route} (HTTP ${resp.status}): ${err.message}`);
+  }
+  if (!resp.ok) {
+    const detail = reply && typeof reply.detail === "string" ? reply.detail : `HTTP ${resp.status}`;
+    const error = new Error(detail);
+    error.status = resp.status;
+    throw error;
+  }
+  return reply;
+}
+
+function fetchWorkInProgress(port, opts) {
+  return backendJson(port, "/api/system/work-in-progress", opts);
+}
+
+function quoteList(names) {
+  const quoted = names.map((n) => `'${n}'`);
+  if (quoted.length <= 2) return quoted.join(" and ");
+  return `${quoted.slice(0, 2).join(", ")} and ${quoted.length - 2} more`;
+}
+
+/** What is about to happen, in the dialog's words. */
+const QUIT = Object.freeze({ title: "Quit GAIA?", verb: "Quitting", confirm: "Quit anyway" });
+const RESTART_FOR_UPDATE = Object.freeze({
+  title: "Restart to update?",
+  verb: "Restarting",
+  confirm: "Restart anyway",
+});
+
+/**
+ * The warning for this work, or null when nothing would be lost.
+ *
+ * @param {{answers: Array<{title: string|null}>, indexing: Array<{filename: string|null}>}} work
+ * @param {string} [verb] "Quitting" or "Restarting".
+ */
+function describeWork(work, verb = QUIT.verb) {
+  const answers = work.answers.map((a) => a.title || "a chat");
+  const files = work.indexing.map((d) => d.filename || "a document");
+  if (answers.length === 0 && files.length === 0) return null;
+
+  const lines = [];
+  if (answers.length === 1) {
+    lines.push(`${verb} stops the answer in ${quoteList(answers)}, and that answer will be lost.`);
+  } else if (answers.length > 1) {
+    lines.push(`${verb} stops the answers in ${quoteList(answers)}, and those answers will be lost.`);
+  }
+  if (files.length > 0) {
+    lines.push(`Indexing ${quoteList(files)} stops too; add ${files.length === 1 ? "it" : "them"} again later.`);
+  }
+  let message;
+  if (files.length === 0) {
+    message = answers.length === 1 ? "GAIA is still writing an answer." : `GAIA is still writing ${answers.length} answers.`;
+  } else if (answers.length === 0) {
+    message = "GAIA is still indexing documents.";
+  } else {
+    message = "GAIA is still working.";
+  }
+  return { message, detail: lines.join("\n\n") };
+}
+
+/**
+ * Whether the quit (or update restart) should go ahead. Asks only when work
+ * would be lost, or when the check itself failed and the answer is unknown.
+ *
+ * @param {{getWork: () => Promise<object>, showMessageBox: (opts: object) => Promise<{response: number}>,
+ *   action?: typeof QUIT}} deps `action` is QUIT (the default) or RESTART_FOR_UPDATE.
+ * @returns {Promise<boolean>}
+ */
+async function confirmQuit({ getWork, showMessageBox, action = QUIT }) {
+  let warning;
+  try {
+    warning = describeWork(await getWork(), action.verb);
+  } catch (err) {
+    warning = {
+      message: "GAIA couldn't check whether it is still working.",
+      detail: `${err.message}\n\nIf an answer is being written, ${action.verb.toLowerCase()} stops it and the answer will be lost.`,
+    };
+  }
+  if (!warning) return true;
+  const { response } = await showMessageBox({
+    type: "warning",
+    title: action.title,
+    message: warning.message,
+    detail: warning.detail,
+    buttons: ["Keep running", action.confirm],
+    defaultId: 0,
+    cancelId: 0,
+    noLink: true,
+  });
+  return response === 1;
+}
+
+/**
+ * Hold every quit until `confirm` agrees, then quit for real.
+ *
+ * Electron's before-quit does not wait for async handlers, so the first quit
+ * is cancelled while the check runs and re-issued once it passes. Quits that
+ * must not ask (an update restart, an OS sign-out or shutdown) call `allow()`.
+ *
+ * @param {{app: Electron.App, updater: NodeJS.EventEmitter,
+ *   shouldAsk: () => boolean, confirm: () => Promise<boolean>,
+ *   onQuitting: () => void, onError: (err: Error) => void, now?: () => number}} deps
+ *   `onError` should tell the user that quitting again within QUIT_ANYWAY_MS
+ *   quits without asking.
+ * @returns {{readonly confirmed: boolean, allow(): void}}
+ */
+function installQuitGuard({ app, updater, shouldAsk, confirm, onQuitting, onError, now = Date.now }) {
+  let confirmed = false;
+  let inFlight = false;
+  // If the question itself can't be shown, a quit soon after goes through, so
+  // a broken dialog can never trap the user in GAIA; a later quit asks again.
+  let quitAnywayUntil = 0;
+  // The restart was already confirmed in the update dialog.
+  updater.on("before-quit-for-update", () => {
+    confirmed = true;
+  });
+  app.on("before-quit", (event) => {
+    if (!confirmed && now() >= quitAnywayUntil && shouldAsk()) {
+      event.preventDefault();
+      if (inFlight) return;
+      inFlight = true;
+      confirm()
+        .then((go) => {
+          inFlight = false;
+          if (!go) {
+            console.log("[quit-guard] Quit cancelled: work still running");
+            return;
+          }
+          confirmed = true;
+          app.quit();
+        })
+        .catch((err) => {
+          inFlight = false;
+          quitAnywayUntil = now() + QUIT_ANYWAY_MS;
+          onError(err);
+        });
+      return;
+    }
+    confirmed = true;
+    onQuitting();
+  });
+  return {
+    get confirmed() {
+      return confirmed;
+    },
+    allow() {
+      confirmed = true;
+    },
+  };
+}
+
+/**
+ * What closing the window does: hide it to the tray (telling the user once),
+ * or, when closing quits, run the quit guard first and keep the window open
+ * until it agrees. An OS sign-out (Windows' session-end) never waits on it.
+ *
+ * @param {Electron.BrowserWindow} win
+ * @param {{app: Electron.App, guard: ReturnType<typeof installQuitGuard>,
+ *   getTray: () => (object|null), isQuitting: () => boolean, platform: string,
+ *   reportNoticeError: (err: Error) => void}} deps
+ */
+function attachWindowGuards(win, { app, guard, getTray, isQuitting, platform, reportNoticeError }) {
+  win.on("close", (event) => {
+    if (isQuitting()) return;
+    const tray = getTray();
+    if (tray && tray.minimizeToTray) {
+      event.preventDefault();
+      win.hide();
+      console.log("[main] Window hidden to tray");
+      if (tray.closeNoticeDue) {
+        Promise.resolve()
+          .then(() => tray.showCloseNotice())
+          .then((quit) => {
+            if (quit) app.quit();
+          })
+          .catch(reportNoticeError);
+      }
+      return;
+    }
+    // macOS keeps the app running without a window, so only there does close just close.
+    if (platform !== "darwin" && !guard.confirmed) {
+      event.preventDefault();
+      app.quit();
+    }
+  });
+  // Windows asks (query-session-end) before it ends the session (session-end).
+  win.on("query-session-end", () => guard.allow());
+  win.on("session-end", () => guard.allow());
+}
+
+module.exports = {
+  QUIT_ANYWAY_MS,
+  attachWindowGuards,
+  backendJson,
+  fetchWorkInProgress,
+  describeWork,
+  confirmQuit,
+  installQuitGuard,
+  QUIT,
+  RESTART_FOR_UPDATE,
+  CHECK_TIMEOUT_MS,
+};