@flame0510/project-aether 1.5.0 → 1.5.1

package/app/api/update-check/route.ts

@@ -68,45 +68,56 @@ export async function GET(request: Request): Promise<NextResponse> {
     }
   }
 
-  return NextResponse.json({ installed, latest, updateAvailable, package: getPackageInfo().name });
+  return NextResponse.json({ installed, latest, updateAvailable, package: getPackageInfo().name, log: 'update.log' });
 }
 
 /**
  * POST /api/update-check
  *
- * Spawns rev4a update as a detached background process.
- * rev4a update installs the latest version and writes .restart-flag,
- * which rev4a serve detects and exits with code 42, then auto-restarts
- * with the newly installed binary. No systemd required.
+ * Spawns `rev4a update` as a detached background process: it installs the latest
+ * version, writes `.restart-flag` and lets `rev4a serve` restart the child (`rev4a
+ * _run`) with the new binary. Nothing here has to restart anything — the update kills
+ * this very process on its way in (`fuser -k <port>/tcp`), so any callback meant to run
+ * after it is dead code; the CLI's own flag is the only mechanism that has to work.
+ *
+ * The child's output goes to `update.log` in the data directory: since the update
+ * restarts this process mid-run, that file is the only record of what happened.
  */
 export async function POST(request: Request): Promise<NextResponse> {
   const denied = await requireAuthJWT(request);
   if (denied) return denied;
 
-  // Spawn rev4a update in background, then write restart flag directly
-  // from this process so rev4a serve detects it and restarts.
   const { spawn } = require('child_process');
   const { join } = require('path');
-  const { writeFileSync } = require('fs');
+  const { openSync, closeSync, appendFileSync } = require('fs');
 
   const dataDir = process.env.REV4A_DATA_DIR ||
     join(process.env.HOME || '/root', '.config', 'rev4a', 'data');
+  const logPath = join(dataDir, 'update.log');
+
+  let log: number | null = null;
+  try {
+    log = openSync(logPath, 'a');
+    appendFileSync(logPath, `\n[${new Date().toISOString()}] rev4a update, started from the dashboard\n`);
+  } catch {
+    // Unwritable log: run the update anyway, we just lose the record.
+  }
 
   const child = spawn('rev4a', ['update'], {
-    stdio: 'ignore',
+    stdio: log === null ? 'ignore' : ['ignore', log, log],
     detached: true,
+    cwd: dataDir,
   });
+  if (log !== null) closeSync(log);
 
-  // When rev4a update finishes, write the restart flag so rev4a serve
-  // picks it up and exits with code 42, triggering the auto-restart loop.
-  child.on('exit', () => {
-    try { writeFileSync(join(dataDir, '.restart-flag'), ''); } catch {}
+  child.on('error', (e: Error) => {
+    try { appendFileSync(logPath, `[dashboard] could not start the update: ${e.message}\n`); } catch {}
   });
-
   child.unref();
 
   return NextResponse.json({
     success: true,
-    message: 'Update started. The dashboard will restart once complete.',
+    message: 'Update started. Rev4a restarts itself once the new version is installed.',
+    log: 'update.log',
   });
 }

package/app/components/VersionBanner.tsx

@@ -1,14 +1,42 @@
 'use client';
 
+/**
+ * "Update available" banner for Rev4a itself.
+ *
+ * The update is spawned by `POST /api/update-check` and restarts the server, so this
+ * component cannot be told the outcome by the response. It records what it asked for,
+ * waits for the server to answer again, and on the next mount compares: if the
+ * installed version moved it was updated, and if the same update is still offered it
+ * did not complete (the log file says why).
+ */
 import { useEffect, useState } from 'react';
 
 interface VersionInfo {
   installed: string;
   latest: string | null;
   updateAvailable: boolean;
+  log?: string;
 }
 
 const DISMISS_KEY = 'rev4a-update-dismissed';
+/** What we asked for and from which version, so the next mount can judge the outcome. */
+const PENDING_KEY = 'rev4a-update-pending';
+
+/** How long to poll for the restart before reloading anyway. */
+const WAIT_MS = 120_000;
+
+interface Pending { target: string; from: string }
+
+function readPending(): Pending | null {
+  try {
+    const raw = sessionStorage.getItem(PENDING_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as Pending;
+    return parsed && typeof parsed.target === 'string' && typeof parsed.from === 'string' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 
 export default function VersionBanner() {
   const [info, setInfo] = useState<VersionInfo | null>(null);
@@ -18,17 +46,37 @@ export default function VersionBanner() {
   const [updateOk, setUpdateOk] = useState<string | null>(null);
 
   useEffect(() => {
+    let active = true;
     fetch('/api/update-check?check=1')
       .then((r) => r.json())
       .then((d: VersionInfo) => {
+        if (!active) return;
+        const pending = readPending();
+        // Back from an update: did the installed version actually move?
+        if (pending && d.installed !== pending.from) {
+          sessionStorage.removeItem(PENDING_KEY);
+          setUpdateOk(`Updated to v${d.installed}`);
+          setTimeout(() => { if (active) window.location.reload(); }, 2000);
+          return;
+        }
+        if (pending) {
+          sessionStorage.removeItem(PENDING_KEY);
+          setInfo(d);
+          setDismissed(false);
+          setUpdateError(
+            `The update to v${pending.target} did not complete: Rev4a is still on v${d.installed}.`
+            + ` See ${d.log ?? 'update.log'} in the Rev4a data directory.`,
+          );
+          return;
+        }
         if (d.updateAvailable) {
           setInfo(d);
           const saved = localStorage.getItem(DISMISS_KEY);
-          if (saved === d.latest) setDismissed(true);
-          else setDismissed(false);
+          setDismissed(saved === d.latest);
         }
       })
       .catch(() => {});
+    return () => { active = false; };
   }, []);
 
   function handleDismiss() {
@@ -39,6 +87,7 @@ export default function VersionBanner() {
   }
 
   async function handleUpdate() {
+    if (!info) return;
     setUpdating(true);
     setUpdateError(null);
     setUpdateOk(null);
@@ -49,21 +98,37 @@ export default function VersionBanner() {
         headers: { 'Content-Type': 'application/json' },
       });
       const data = await res.json();
-      if (data.success) {
-        setUpdateOk('Update started. Restarting\u2026');
-        localStorage.removeItem(DISMISS_KEY);
-        setTimeout(function() { window.location.reload(); }, 5000);
-      } else {
+      if (!data.success) {
         setUpdateError(data.error || 'Update failed');
         setUpdating(false);
+        return;
       }
+      sessionStorage.setItem(PENDING_KEY, JSON.stringify({ target: info.latest ?? '', from: info.installed }));
+      localStorage.removeItem(DISMISS_KEY);
+      setUpdateOk('Update started. Rev4a is restarting…');
+      // The server goes down and comes back on the new version: wait for its answer,
+      // then reload. A timeout reloads too — the next mount reports the outcome.
+      const deadline = Date.now() + WAIT_MS;
+      const poll = async () => {
+        if (Date.now() > deadline) { window.location.reload(); return; }
+        try {
+          const r = await fetch('/api/update-check', { cache: 'no-store' });
+          const d = (await r.json()) as VersionInfo;
+          if (d.installed !== info.installed) { window.location.reload(); return; }
+        } catch { /* the server is down for the update: expected */ }
+        setTimeout(poll, 3000);
+      };
+      setTimeout(poll, 3000);
     } catch (err) {
       setUpdateError(err instanceof Error ? err.message : 'Network error');
       setUpdating(false);
     }
   }
 
-  if (!info || dismissed) return null;
+  // The result states stand on their own (there may be no `info` when the update just
+  // succeeded); the "available" state needs the version info and no dismissal.
+  const show = Boolean(updateOk) || Boolean(updateError) || Boolean(info?.updateAvailable && !dismissed);
+  if (!show) return null;
 
   return (
     <div className="update-banner">
@@ -73,25 +138,25 @@ export default function VersionBanner() {
             <span className="update-banner__ok">{updateOk}</span>
           ) : updateError ? (
             <span className="update-banner__err">{updateError}</span>
-          ) : (
+          ) : info ? (
             <>
               <span className="update-banner__label">Update available</span>
               <span className="update-banner__sep">&mdash;</span>
               <span className="update-banner__version">v{info.latest}</span>
               <span className="update-banner__sep">(installed: v{info.installed})</span>
             </>
-          )}
+          ) : null}
         </span>
 
         {!updateOk && (
           <div className="update-banner__actions">
             {updateError ? (
               <button className="ui-btn ui-btn--primary ui-btn--sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating\u2026' : 'Retry'}
+                {updating ? 'Updating…' : 'Retry'}
               </button>
             ) : (
               <button className="ui-btn ui-btn--primary ui-btn--sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating\u2026' : 'Update now'}
+                {updating ? 'Updating…' : 'Update now'}
               </button>
             )}
             <button className="ui-btn ui-btn--ghost ui-btn--sm" onClick={handleDismiss}>

package/docs/dev/API-REFERENCE.md

@@ -2559,14 +2559,28 @@ Installed version against the latest published one.
 **Query params:** `check=1` queries the registry; without it the answer comes
 from local state only.
 
-**Response:** `{ "installed": "1.1.15", "latest": "1.1.16", "updateAvailable": true, "package": "@flame0510/project-aether" }`
+**Response:** `{ "installed": "1.4.2", "latest": "1.5.0", "updateAvailable": true, "package": "@flame0510/project-aether", "log": "update.log" }`
+
+`log` is the file name, in the Rev4a data directory, where the update's output is
+written.
 
 ### `POST /api/update-check`
-Run `rev4a update` as a detached background process. The dashboard restarts
-itself as part of the update, so the connection drops.
+Run `rev4a update` as a detached background process. Nothing here restarts anything:
+the update kills this process on its way in (`fuser -k <port>/tcp`) and `rev4a serve`
+brings the child back on the new binary via its `.restart-flag`, so the connection
+drops and the page has to wait for the server to answer again.
+
+The child's output goes to `update.log` in the data directory — the update restarts
+the process that spawned it, so that file is the only record of what happened.
 
 **Auth:** browser cookie or bearer token
 
+**Response:** `{ "success": true, "message": "...", "log": "update.log" }`
+
+The banner records what it asked for, polls `/api/version` until the installed version
+moves (or two minutes pass), reloads, and on the next mount either confirms
+"Updated to vX" or reports that the update did not complete and points at the log.
+
 ### `GET /api/alerts/smoke`
 Send a test alert, to verify the Telegram alerting path end to end.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flame0510/project-aether",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Rev4a — Revolution for Agents. OpenClaw agent fleet orchestrator.",
   "keywords": [
     "openclaw",