@amd-gaia/agent-ui 0.21.1 → 0.22.0

package/dist/index.html

@@ -4,9 +4,9 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <title>GAIA</title>
-  <script type="module" crossorigin src="./assets/index-Dj-STgr2.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-DRnhDSoO.css">
+    <title>GAIA Agent UI</title>
+  <script type="module" crossorigin src="./assets/index-lScW7mUY.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-B31DMoxr.css">
 </head>
 <body>
     <div id="root"></div>

package/main-safety-net.cjs

@@ -134,12 +134,22 @@ function installSafetyNet({ logPath, dialogModule, appModule, homedirFn }) {
 
   appModule.on("child-process-gone", (_event, details) => {
     const reason = details && details.reason;
+    const type = details && details.type;
     // Ignore expected terminations during shutdown so the crash dialog
     // doesn't flash on a clean quit.
     if (reason === "clean-exit" || reason === "killed") return;
-    fatal(new Error(
-      `child-process-gone: type=${details && details.type} reason=${reason}`
-    ));
+    // A GPU-process crash is recoverable — Chromium relaunches the GPU process
+    // and falls back to software rendering. It fires routinely in GPU-less
+    // environments (Windows Sandbox, VMs, RDP), so log it and keep running
+    // instead of killing an otherwise-healthy app.
+    if (type === "GPU") {
+      appendLog(
+        logPath,
+        `[${new Date().toISOString()}] GPU_PROCESS_GONE reason=${reason}`
+      );
+      return;
+    }
+    fatal(new Error(`child-process-gone: type=${type} reason=${reason}`));
   });
 
   return { fatal };

package/main.cjs

@@ -783,6 +783,9 @@ app.whenReady().then(async () => {
     if (seedResult.seeded.length > 0) {
       console.log("[main] Seeded agents:", seedResult.seeded);
     }
+    if (seedResult.cleaned.length > 0) {
+      console.log("[main] Cleaned legacy agents:", seedResult.cleaned);
+    }
     if (seedResult.errors.length > 0) {
       console.warn(
         "[main] Agent seeding errors:",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amd-gaia/agent-ui",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "type": "module",
   "productName": "GAIA Agent UI",
   "description": "Privacy-first agentic AI interface with document Q&A - runs 100% locally on AMD Ryzen AI",
@@ -70,7 +70,7 @@
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.2",
-    "electron": "^42.2.0",
+    "electron": "^43.0.0",
     "electron-builder": "^26.8.1",
     "jsdom": "^29.1.1",
     "lucide-react": "^1.17.0",
@@ -81,7 +81,7 @@
     "react-markdown": "^10.1.0",
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
     "vite": "^8.0.16",
     "vitest": "^4.1.8",
     "zustand": "^5.0.14"

package/preload.cjs

@@ -85,7 +85,7 @@ contextBridge.exposeInMainWorld("gaiaInstall", {
 // available" chip without pulling in the full gaiaAPI surface. Mirrors
 // the naming convention (gaiaInstall, gaiaUpdater, gaiaAPI).
 contextBridge.exposeInMainWorld("gaiaUpdater", {
-  /** Get the current update state (status, version, progress, error). */
+  /** Get the current update state (status, version, progress, error, currentVersion, pinnedVersion). */
   getStatus: () => ipcRenderer.invoke("gaia:update:get-status"),
 
   /** Manually trigger a check. Resolves with the post-check state. */
@@ -100,4 +100,25 @@ contextBridge.exposeInMainWorld("gaiaUpdater", {
     ipcRenderer.on("gaia:update:status", handler);
     return () => ipcRenderer.removeListener("gaia:update:status", handler);
   },
+
+  /**
+   * Fetch available GitHub releases for this platform. Resolves with an
+   * array of ReleaseInfo objects (newest first) or { error: string } when
+   * the network call fails.
+   */
+  listReleases: () => ipcRenderer.invoke("gaia:update:list-releases"),
+
+  /**
+   * Download and install a specific tagged release, then prompt restart.
+   * Persists a version pin so auto-update stays paused (AC2).
+   *
+   * @param {string} tag  e.g. "v0.20.0"
+   */
+  installVersion: (tag) => ipcRenderer.invoke("gaia:update:install-version", tag),
+
+  /**
+   * Resume normal auto-updates — clears the version pin set by installVersion.
+   * Resolves with the updated state.
+   */
+  resumeUpdates: () => ipcRenderer.invoke("gaia:update:resume"),
 });

package/services/agent-seeder.cjs

@@ -16,20 +16,40 @@
  *              - macOS:   <Bundle>.app/Contents/Resources/agents/<id>/
  *              - Linux:   /opt/<AppName>/resources/agents/<id>/
  *   - Target:  path.join(os.homedir(), ".gaia", "agents", "<id>")
- *   - Sentinel: <target>/.seeded  (exists → already seeded → skip)
+ *   - Sentinel: <target>/.seeded  (this copy completed)
+ *   - Marker:  ~/.gaia/seeder/<id>.seeded  ("this machine seeded <id> once";
+ *     EXISTENCE is the signal — content is informational, never parsed for
+ *     decisions. Lives outside ~/.gaia/agents/ so deleting an agent, or the
+ *     whole agents dir, never resurrects it.)
  *
  * Write protocol (atomic-ish, crash-safe):
  *   1. Remove any stale `<id>.partial/` sibling from a prior failed run.
  *   2. Copy source → `<id>.partial/`.
  *   3. `fs.renameSync(<id>.partial, <id>)` — atomic on the same filesystem.
- *   4. Write `<id>/.seeded` last, so a partial seed never looks complete.
+ *   4. Write `<id>/.seeded`, so a partial seed never looks complete.
+ *   5. Write the marker LAST — a crash between 4 and 5 self-heals next
+ *      launch via the marker back-fill (rule 2 below).
+ *
+ * Per-agent decision order (markers read fresh on every call, no caching):
+ *   1. Marker exists → skip, full stop. A deleted agent is never re-seeded;
+ *      a dir the user re-created under the same id is never touched.
+ *   2. No marker, target has `.seeded` → back-fill the marker, skip.
+ *   3. No marker, target exists WITHOUT `.seeded` → user-owned data,
+ *     log a warning, skip, write no marker.
+ *   4. No marker, no target → seed via the write protocol above.
+ *
+ * Recovery: to get a deleted bundled agent back, remove
+ * `~/.gaia/seeder/<id>.seeded` and relaunch.
+ *
+ * Legacy cleanup: the retired `zoo-agent` demo is removed from
+ * ~/.gaia/agents/ when it is provably an unmodified seeded copy — sentinel
+ * present, no file newer than its seededAt (+5s slack), never through a
+ * symlink. Removed ids are reported via the additive `cleaned` array.
  *
  * Behaviour:
- *   - Target `<id>/` exists WITH `.seeded` → already seeded, skip.
- *   - Target `<id>/` exists WITHOUT `.seeded` → treat as user-owned data,
- *     log a warning, and skip (never clobber a hand-authored agent).
- *   - `process.resourcesPath` unset (dev / Jest) or source dir missing →
- *     empty result, no error.
+ *   - `process.resourcesPath` unset (dev / Jest) → empty result, no error,
+ *     no cleanup (never touch the real HOME from dev/test contexts).
+ *   - Source dir missing → legacy cleanup still runs, then empty result.
  *   - Per-agent failures are isolated: they go into `errors[]` but do not
  *     stop the next agent from being seeded.
  *
@@ -53,6 +73,10 @@ function agentsTargetRoot() {
   return path.join(gaiaHome(), "agents");
 }
 
+function seederMarkersDir() {
+  return path.join(gaiaHome(), "seeder");
+}
+
 function logsDir() {
   return path.join(gaiaHome(), "logs");
 }
@@ -124,6 +148,48 @@ function isDirectory(p) {
   }
 }
 
+// ── Marker helpers ───────────────────────────────────────────────────────
+
+/**
+ * Defense-in-depth: an agent id must be a single plain path segment before
+ * it is used in any path.join or marker filename.
+ */
+function isSinglePathSegment(id) {
+  return (
+    typeof id === "string" &&
+    id.length > 0 &&
+    id !== "." &&
+    id !== ".." &&
+    !id.includes("/") &&
+    !id.includes("\\") &&
+    !id.includes(path.sep)
+  );
+}
+
+function markerPath(id) {
+  if (!isSinglePathSegment(id)) {
+    throw new Error(`Invalid agent id for marker path: ${JSON.stringify(id)}`);
+  }
+  return path.join(seederMarkersDir(), `${id}.seeded`);
+}
+
+function hasMarker(id) {
+  return fs.existsSync(markerPath(id));
+}
+
+function writeMarker(id, source) {
+  fs.mkdirSync(seederMarkersDir(), { recursive: true });
+  fs.writeFileSync(
+    markerPath(id),
+    JSON.stringify(
+      { seededAt: new Date().toISOString(), source },
+      null,
+      2
+    ),
+    { encoding: "utf8" }
+  );
+}
+
 // ── Seeding core ─────────────────────────────────────────────────────────
 
 /**
@@ -135,18 +201,42 @@ function isDirectory(p) {
  * Throws only on programmer error. All IO errors are caught and logged.
  */
 function seedOneAgent(sourceDir, targetRoot, id) {
+  if (!isSinglePathSegment(id)) {
+    log("WARN", `Skipping invalid agent id ${JSON.stringify(id)}`);
+    return { status: "skipped" };
+  }
+
   const src = path.join(sourceDir, id);
   const target = path.join(targetRoot, id);
   const partial = path.join(targetRoot, `${id}.partial`);
   const sentinel = path.join(target, ".seeded");
 
-  // Already seeded?
+  // Rule 1: marker wins, full stop — honors deletion and leaves any
+  // user-recreated dir under the same id untouched.
+  if (hasMarker(id)) {
+    log("INFO", `Skipping "${id}" — already seeded once on this machine (marker present)`);
+    return { status: "skipped" };
+  }
+
+  // Rule 2: seeded before markers existed → back-fill the marker.
+  // Runs every launch, so it also heals a crash between sentinel and marker.
   if (fs.existsSync(sentinel)) {
-    log("INFO", `Skipping "${id}" — already seeded (sentinel present)`);
+    try {
+      writeMarker(id, src);
+      log("INFO", `Skipping "${id}" — already seeded (sentinel present); marker back-filled`);
+    } catch (err) {
+      log(
+        "ERROR",
+        `Failed to back-fill marker for "${id}": ${
+          err && err.message ? err.message : err
+        } — will retry next launch`
+      );
+    }
     return { status: "skipped" };
   }
 
-  // Target exists but no sentinel → user-owned data. Do not touch.
+  // Rule 3: target exists but no sentinel → user-owned data. Do not touch,
+  // write no marker.
   if (fs.existsSync(target)) {
     log(
       "WARN",
@@ -176,7 +266,7 @@ function seedOneAgent(sourceDir, targetRoot, id) {
     copyDirRecursive(src, partial);
     fs.renameSync(partial, target);
 
-    // Write sentinel LAST — its presence means "copy completed".
+    // Write sentinel — its presence means "copy completed".
     fs.writeFileSync(
       sentinel,
       JSON.stringify(
@@ -190,6 +280,9 @@ function seedOneAgent(sourceDir, targetRoot, id) {
       { encoding: "utf8" }
     );
 
+    // Marker LAST — a crash here self-heals via the rule-2 back-fill.
+    writeMarker(id, src);
+
     log("INFO", `Seeded "${id}" from ${src} to ${target}`);
     return { status: "seeded" };
   } catch (err) {
@@ -214,15 +307,156 @@ function seedOneAgent(sourceDir, targetRoot, id) {
   }
 }
 
+// ── Legacy cleanup ───────────────────────────────────────────────────────
+
+// Retired bundled ids removed from user machines when provably unmodified.
+const LEGACY_CLEANUP_IDS = ["zoo-agent"];
+
+// Filesystem mtime granularity + copy latency headroom for the
+// modified-since-seed check.
+const MODIFIED_SLACK_MS = 5000;
+
+function listFilesRecursive(dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    // __pycache__/*.pyc is regenerated by the registry on every load — it
+    // postdates seededAt but is not a user modification.
+    if (entry.isDirectory() && entry.name === "__pycache__") continue;
+    if (!entry.isDirectory() && entry.name.endsWith(".pyc")) continue;
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listFilesRecursive(p));
+    } else {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+/**
+ * Remove retired seeded demo agents (currently `zoo-agent`) from
+ * ~/.gaia/agents/. Deletes ONLY when the dir is provably an unmodified
+ * seeded copy; anything ambiguous is left in place. Failures are logged
+ * and retried on the next launch (the sentinel keys the retry — no marker
+ * is involved, since a retired id can never be re-seeded anyway).
+ *
+ * @returns {string[]} ids actually removed (verified gone from disk).
+ */
+function cleanupLegacyAgents() {
+  const cleaned = [];
+
+  for (const id of LEGACY_CLEANUP_IDS) {
+    const target = path.join(agentsTargetRoot(), id);
+
+    let st;
+    try {
+      st = fs.lstatSync(target);
+    } catch {
+      continue; // not present — nothing to clean
+    }
+
+    // Never rm through a symlink — it would delete the link target.
+    if (st.isSymbolicLink()) {
+      log(
+        "WARN",
+        `Legacy "${id}" at ${target} is a symlink — leaving it untouched`
+      );
+      continue;
+    }
+
+    if (!st.isDirectory()) {
+      log("WARN", `Legacy "${id}" at ${target} is not a directory — leaving it untouched`);
+      continue;
+    }
+
+    // No sentinel → user-authored, not ours to remove.
+    const sentinel = path.join(target, ".seeded");
+    if (!fs.existsSync(sentinel)) {
+      continue;
+    }
+
+    let seededAtMs;
+    try {
+      seededAtMs = Date.parse(
+        JSON.parse(fs.readFileSync(sentinel, "utf8")).seededAt
+      );
+      if (!Number.isFinite(seededAtMs)) {
+        throw new Error("seededAt missing or not a valid timestamp");
+      }
+    } catch (err) {
+      log(
+        "WARN",
+        `Cannot determine seededAt for legacy "${id}" (${
+          err && err.message ? err.message : err
+        }) — treating as user-modified, leaving it untouched`
+      );
+      continue;
+    }
+
+    // Any file newer than the seed time means the user customized it —
+    // it is their work now, never delete it.
+    let modified = false;
+    try {
+      for (const file of listFilesRecursive(target)) {
+        if (fs.lstatSync(file).mtimeMs > seededAtMs + MODIFIED_SLACK_MS) {
+          log(
+            "WARN",
+            `Legacy "${id}" was modified after seeding (${file}) — leaving it untouched`
+          );
+          modified = true;
+          break;
+        }
+      }
+    } catch (err) {
+      log(
+        "WARN",
+        `Cannot inspect legacy "${id}" for modifications (${
+          err && err.message ? err.message : err
+        }) — leaving it untouched`
+      );
+      continue;
+    }
+    if (modified) {
+      continue;
+    }
+
+    try {
+      fs.rmSync(target, { recursive: true, force: true });
+    } catch (err) {
+      log(
+        "ERROR",
+        `Failed to remove legacy "${id}" at ${target}: ${
+          err && err.message ? err.message : err
+        } — will retry next launch`
+      );
+      continue;
+    }
+
+    // Report success only after verifying it is actually gone.
+    if (fs.existsSync(target)) {
+      log(
+        "ERROR",
+        `Legacy "${id}" still present after removal attempt: ${target} — will retry next launch`
+      );
+      continue;
+    }
+
+    log("INFO", `Removed legacy seeded agent "${id}" from ${target}`);
+    cleaned.push(id);
+  }
+
+  return cleaned;
+}
+
 /**
  * Seed all bundled agents found under `<resourcesPath>/agents/`.
  *
  * Idempotent — safe to call on every app launch.
  *
- * @returns {Promise<{seeded: string[], skipped: string[], errors: {id: string, error: Error}[]}>}
+ * @returns {Promise<{seeded: string[], skipped: string[], errors: {id: string, error: Error}[], cleaned: string[]}>}
  */
 async function seedBundledAgents() {
-  const result = { seeded: [], skipped: [], errors: [] };
+  const result = { seeded: [], skipped: [], errors: [], cleaned: [] };
 
   // Guard against dev / test environments where resourcesPath is unset.
   if (!process.resourcesPath) {
@@ -233,6 +467,11 @@ async function seedBundledAgents() {
     return result;
   }
 
+  // Legacy cleanup runs before the missing-source guard: an upgraded
+  // install must shed the retired zoo-agent even if this build ships no
+  // bundled agents.
+  result.cleaned = cleanupLegacyAgents();
+
   const sourceDir = path.join(process.resourcesPath, "agents");
 
   if (!fs.existsSync(sourceDir) || !isDirectory(sourceDir)) {
@@ -284,7 +523,8 @@ async function seedBundledAgents() {
   log(
     "INFO",
     `Seeding complete — seeded=${result.seeded.length} ` +
-      `skipped=${result.skipped.length} errors=${result.errors.length}`
+      `skipped=${result.skipped.length} errors=${result.errors.length} ` +
+      `cleaned=${result.cleaned.length}`
   );
 
   return result;
@@ -295,7 +535,9 @@ module.exports = {
   // Exposed for tests — do not rely on these from production code.
   _internals: {
     seedOneAgent,
+    cleanupLegacyAgents,
     agentsTargetRoot,
+    seederMarkersDir,
     logFilePath,
   },
 };