aegis-desktop 0.8.12 → 0.8.13

package/renderer/app.js

@@ -42,6 +42,12 @@ const quickLauncher = window.quickLauncher;
 // has no `queue` key, and every function below no-ops on it rather than
 // crashing boot the way a chat flow without window.aegis would.
 const queueApi = window.queue;
+// The two opt-in automations (main.js registerAutoIpc -> lib/auto.js). Guarded
+// everywhere it is used, for the same reason queueApi is: a preload predating
+// this surface has no `window.auto` at all, and the toggles must degrade to
+// inert markup rather than throwing at boot and taking every later binding with
+// them.
+const autoApi = window.auto;
 
 if (!aegis || !models) {
   document.body.textContent =
@@ -126,6 +132,13 @@ const ELEMENT_IDS = {
   memoryCount: 'memory-count',
   memoryOverlayEntry: 'memory-overlay-entry',
   memoryOverlaySave: 'memory-overlay-save',
+  // φ(α). The panel's own nodes are read by desktop/renderer/fingerprint.js,
+  // which declares them itself; app.js only needs the sidebar state line it
+  // writes when mount() throws. Listed here all the same so the "every id
+  // app.js asks for exists in index.html" check covers them.
+  fpCardStatus: 'fp-card-status',
+  fpOpen: 'fp-open',
+  fpOverlay: 'fp-overlay',
   messages: 'messages',
   composer: 'composer',
   prompt: 'prompt',
@@ -142,6 +155,10 @@ const ELEMENT_IDS = {
   queueHint: 'queue-hint',
   queueFanout: 'queue-fanout',
   queueFanoutLabel: 'queue-fanout-label',
+  queueAuto: 'queue-auto',
+  queueAutoLabel: 'queue-auto-label',
+  queueAutoInterval: 'queue-auto-interval',
+  queueAutoHint: 'queue-auto-hint',
   queueBoundary: 'queue-boundary',
   queueUpgrade: 'queue-upgrade',
 };
@@ -1543,6 +1560,119 @@ async function queueTaskAction(name, id) {
   }
 }
 
+/**
+ * The auto-drain control on the queue card (main.js registerAutoIpc ->
+ * desktop/lib/auto.js -> settings.js `__autoDrain`).
+ *
+ * This is the ONE thing on this card that can start a drain with no click, and
+ * it exists because the user asked for it explicitly. Everything the queue
+ * section above promises is still true of a default install: the switch is
+ * off, main.js's timer is not even created, and nothing drains at boot or on
+ * idle. What changed is that "off" is now a persisted default rather than an
+ * absolute — so the honesty this file owes is a truthful paint of that switch,
+ * including when the timer is armed but skipping (another host holds the lock,
+ * the queue is empty), which is the state that otherwise reads as "the feature
+ * is broken".
+ */
+function renderAutoDrain(state) {
+  if (!els.queueAuto || !state || typeof state !== 'object') return;
+  const enabled = state.enabled === true;
+  els.queueAuto.checked = enabled;
+  if (els.queueAutoInterval) {
+    // A pick is only meaningful while the switch is on; disabling it keeps the
+    // select from reading as an armed cadence next to an off switch.
+    els.queueAutoInterval.disabled = !enabled;
+    const ms = Number(state.intervalMs);
+    if (Number.isFinite(ms)) els.queueAutoInterval.value = String(ms);
+  }
+  if (els.queueAutoLabel) {
+    els.queueAutoLabel.textContent = enabled
+      ? `drain automatically · ${formatAutoInterval(state.intervalMs)}`
+      : 'drain automatically';
+  }
+  if (!els.queueAutoHint) return;
+  if (!enabled) {
+    els.queueAutoHint.textContent = 'off — Run one / Drain all are the only triggers';
+    return;
+  }
+  const bits = [];
+  if (state.busy) bits.push('a drain is running');
+  else if (state.armed) bits.push('armed');
+  if (state.ticks) bits.push(`${state.ticks} tick${state.ticks === 1 ? '' : 's'}`);
+  if (state.drains) bits.push(`${state.drains} drained`);
+  const skip = state.lastSkip && state.lastSkip.reason;
+  if (skip) bits.push(`last check skipped: ${autoSkipText(skip, state.lastSkip)}`);
+  else if (!state.ticks) bits.push('first check one interval after arming');
+  els.queueAutoHint.textContent = bits.join(' · ');
+}
+
+/** The skip reasons lib/auto.js records, in the card's own words. An
+ *  unrecognised reason is shown verbatim rather than dropped: a new skip the
+ *  card does not know about is exactly the one worth reading. */
+function autoSkipText(reason, detail = {}) {
+  if (reason === 'empty') return 'queue is empty';
+  if (reason === 'busy') return 'the previous drain is still running';
+  if (reason === 'locked') {
+    const pid = detail.holder && detail.holder.pid;
+    return pid ? `another drain holds the lock (pid ${pid})` : 'another drain holds the lock';
+  }
+  if (reason === 'disabled') return 'switched off';
+  if (reason === 'no queue access') return 'this window has no queue access';
+  return String(reason);
+}
+
+function formatAutoInterval(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n) || n <= 0) return 'every interval';
+  if (n < 60_000) return `every ${Math.round(n / 1000)}s`;
+  const min = n / 60_000;
+  return Number.isInteger(min) ? `every ${min} min` : `every ${min.toFixed(1)} min`;
+}
+
+/** Paint both automation states from main's answer (`auto.status()`). */
+function renderAutoStatus(payload) {
+  if (!payload || typeof payload !== 'object') return;
+  if (payload.drain) renderAutoDrain(payload.drain);
+  if (typeof renderAutoMint === 'function' && payload.mint) renderAutoMint(payload.mint);
+}
+
+/**
+ * Load the two switches and paint them. A read, never an arm: main.js is what
+ * armed the timer at boot, from the same persisted settings this paints.
+ */
+async function loadAutoState() {
+  if (!autoApi || typeof autoApi.status !== 'function') return null;
+  try {
+    const state = await autoApi.status();
+    renderAutoStatus(state);
+    return state;
+  } catch (err) {
+    if (els.queueAutoHint) {
+      els.queueAutoHint.textContent = `automation status unavailable: ${err && err.message ? err.message : err}`;
+    }
+    return null;
+  }
+}
+
+/** The drain toggle. Persists through main, then paints what main says it
+ *  persisted — never the optimistic checkbox state. */
+async function setAutoDrain(enabled) {
+  if (!autoApi || typeof autoApi.setDrain !== 'function') return;
+  const patch = { enabled: Boolean(enabled) };
+  if (els.queueAutoInterval && els.queueAutoInterval.value) {
+    patch.intervalMs = Number(els.queueAutoInterval.value);
+  }
+  try {
+    const res = await autoApi.setDrain(patch);
+    if (res && res.ok === false) {
+      if (els.queueAutoHint) els.queueAutoHint.textContent = res.error || 'could not save that';
+    }
+    renderAutoStatus(res);
+  } catch (err) {
+    if (els.queueAutoHint) els.queueAutoHint.textContent = `could not save that: ${err && err.message ? err.message : err}`;
+  }
+}
+
 /** Live drain progress -> one status line. `delta`/`reasoning` frames are
  *  deliberately dropped: they are a worker's own output, and the place for a
  *  task's result is its row (from queue.list()), not the open transcript. */
@@ -1628,10 +1758,35 @@ const memoryView = {
   loading: false,
 };
 
+/** Is any sheet up?
+ *
+ *  Both overlays count, because the one thing this predicate is used for is
+ *  Escape precedence: while a sheet is open, Escape must not reach past it to
+ *  cancel a turn the user may not be looking at (see the bindEscapeInterrupt
+ *  call). The memory inspector and the φ(α) panel are each opened over the same
+ *  sidebar, so "an overlay is open" has to mean either one — the wiring guard in
+ *  test/renderer-wiring.test.mjs pins this name against exactly that job.
+ *
+ *  Callers that mean the MEMORY inspector specifically — which one is up decides
+ *  where a save reads from and what gets repainted — ask memoryOverlayOpen()
+ *  instead. Confusing the two is how a save would read a hidden textarea. */
 function overlayOpen() {
+  if (memoryOverlayOpen()) return true;
+  return !!(window.aegisFingerprint && window.aegisFingerprint.isOpen());
+}
+
+/** The memory inspector alone. Split out of overlayOpen() when the authorship
+ *  panel gained the same Escape treatment: the two questions were the same
+ *  question right up until there was a second sheet. */
+function memoryOverlayOpen() {
   return !!els.memoryOverlay && !els.memoryOverlay.hidden;
 }
 
+/** The φ(α) panel handle, set by init() when desktop/renderer/fingerprint.js is
+ *  loaded. Kept here rather than inside fingerprint.js so the Escape policy
+ *  above can ask it whether it is open without reaching into its internals. */
+let fpPanel = null;
+
 /** "3m ago" / "2d ago" from epoch ms. Empty string when unknown. */
 function relTime(ms) {
   if (!Number.isFinite(ms)) return '';
@@ -1927,7 +2082,7 @@ function renderMemoryChips() {
 
 /** Repaint the inspector from `memoryView`. Pure — makes no network calls. */
 function renderMemoryOverlay() {
-  if (!overlayOpen()) return;
+  if (!memoryOverlayOpen()) return;
   const total = memoryView.entries.length;
   els.memoryList.innerHTML = '';
   renderMemoryChips();
@@ -2040,7 +2195,7 @@ function closeMemoryOverlay() {
 /** Textarea the save button should read from — the inspector's when it is up,
  *  otherwise the sidebar's. Keeps both save paths on one code path. */
 function activeMemoryEntry() {
-  return overlayOpen() && els.memoryOverlayEntry ? els.memoryOverlayEntry : els.memoryEntry;
+  return memoryOverlayOpen() && els.memoryOverlayEntry ? els.memoryOverlayEntry : els.memoryEntry;
 }
 
 async function importMemory() {
@@ -2123,7 +2278,7 @@ async function saveMemory() {
 async function refreshMemoryViews() {
   const q = els.memoryQuery ? els.memoryQuery.value.trim() : '';
   await searchMemory(q);
-  if (overlayOpen()) await loadMemoryOverlay(memoryView.query);
+  if (memoryOverlayOpen()) await loadMemoryOverlay(memoryView.query);
 }
 
 // ------------------------------------------------------------ chat welcome
@@ -4288,6 +4443,27 @@ async function init() {
     await loadQueueState();
   }
 
+  // ── the two automation switches ──────────────────────────────────────────
+  // Guarded like the queue block above (a preload predating registerAutoIpc has
+  // no window.auto). The `change` handlers are the ONLY things that arm a
+  // timer: loadAutoState() below reads and paints, and main.js armed whatever
+  // was already persisted before this window existed. Nothing here fires one on
+  // its own.
+  if (autoApi) {
+    if (els.queueAuto) {
+      els.queueAuto.addEventListener('change', () => setAutoDrain(els.queueAuto.checked));
+    }
+    if (els.queueAutoInterval) {
+      // A cadence change while armed re-arms the timer in main.js (arm() sees a
+      // new intervalMs); while off it only persists, which is what the user
+      // picked the value for.
+      els.queueAutoInterval.addEventListener('change', () => {
+        if (els.queueAuto && els.queueAuto.checked) setAutoDrain(true);
+      });
+    }
+    await loadAutoState();
+  }
+
   // The transcript's scroll/paint/Escape policy. Both listeners are registered
   // inside transcript-view.js so the behaviours they enforce are the ones
   // test/renderer-dom.test.mjs drives: the passive `scroll` listener is the
@@ -4315,8 +4491,20 @@ async function init() {
     doc: document,
     // The memory overlay wins: while it is open, Escape closes it rather than
     // reaching past it to cancel a turn the user may not be looking at.
+    //
+    // φ(α) is composed into overlayOpen() rather than given its own listener:
+    // two keydown handlers racing to consume one Escape is how a panel ends up
+    // closing and a turn getting cancelled by the same keypress. The escaping
+    // order is the φ(α) panel first only because it is the outermost sheet when
+    // both are somehow up.
     isOverlayOpen: overlayOpen,
-    onOverlayEscape: closeMemoryOverlay,
+    onOverlayEscape: () => {
+      if (window.aegisFingerprint && window.aegisFingerprint.isOpen()) {
+        window.aegisFingerprint.close();
+        return;
+      }
+      closeMemoryOverlay();
+    },
     hasPendingTurn: () => !!pendingSessionId,
     stopTurn: stopPendingTurn,
   });
@@ -4373,6 +4561,22 @@ async function init() {
   await refreshSyncStatus();
   loadAccountInfo();
   searchMemory('');
+
+  // φ(α). `?`-guarded like the update banner above: desktop/renderer/
+  // fingerprint.js owns its own markup and its own listeners, so the sidebar
+  // card and the panel are painted from one mount call and a missing bridge
+  // (a host that predates the IPC handlers) leaves the card on "checking…"
+  // instead of crashing boot. Not awaited: the panel's first status read is a
+  // filesystem stat, and the welcome panel must not wait on it.
+  if (window.aegisFingerprint) {
+    try {
+      fpPanel = window.aegisFingerprint.mount({ api: aegis });
+      fpPanel.refresh().catch(() => {});
+    } catch (e) {
+      const card = els.fpCardStatus;
+      if (card) card.textContent = `authorship panel unavailable: ${(e && e.message) || e}`;
+    }
+  }
 }
 
 // Boot only after the DOM is parsed so every control this script queries

package/renderer/fingerprint.css

@@ -0,0 +1,143 @@
+/* ---------------------------------------------------------- φ(α) panel
+   The panel reuses the memory inspector's sheet (.memory-overlay /
+   .memory-panel, style.css:483+) so the two overlays are the same object to the
+   eye — one translucent layer, one sheet, Escape closes both. Only the rows the
+   fingerprint panel adds are styled here, in their own file, because
+   style.css is not where this feature lives.
+
+   Loaded by index.html after style.css; `style-src 'self'` allows it. */
+
+.fp-rows {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 2px 18px;
+  padding: 12px 16px 4px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--text2);
+}
+
+.fp-row {
+  display: flex;
+  gap: 6px;
+  min-width: 0;
+}
+
+.fp-k {
+  color: var(--text3, var(--text2));
+  opacity: 0.75;
+}
+
+.fp-v {
+  color: var(--text);
+  overflow-wrap: anywhere;
+}
+
+/* The 0644 refusal and any other "the fix is a command" message. Warning
+   colour, not error colour: the key works, it is just readable by others. */
+.fp-warn {
+  margin: 6px 16px 0;
+  font-size: 11px;
+  font-family: var(--font-mono);
+  color: var(--warn, #e0a33a);
+  overflow-wrap: anywhere;
+}
+
+.fp-warn[hidden] {
+  display: none;
+}
+
+.fp-controls {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 16px 0;
+}
+
+.fp-line {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+}
+
+/* The backup row sits outside .fp-controls, so it carries its own inset.
+   A class rather than a style attribute — the CSP is `style-src 'self'`. */
+.fp-line-inset {
+  padding: 8px 16px 0;
+}
+
+.fp-line input[type='text'] {
+  flex: 1;
+  min-width: 0;
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 6px 8px;
+  font: inherit;
+  font-size: 12px;
+}
+
+.fp-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding: 8px 16px 0;
+}
+
+.fp-vault-list {
+  list-style: none;
+  margin: 6px 0 0;
+  padding: 0 16px;
+  max-height: 150px;
+  overflow: auto;
+}
+
+.fp-vault-row {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  padding: 4px 0;
+  border-bottom: 1px solid var(--border);
+  font-size: 11px;
+  font-family: var(--font-mono);
+}
+
+.fp-vault-name {
+  color: var(--text);
+  overflow-wrap: anywhere;
+}
+
+.fp-vault-detail {
+  color: var(--text2);
+  overflow-wrap: anywhere;
+}
+
+/* The result line. `fp-bad` is a refusal, which is always a sentence naming
+   the reason — never a blank pane that reads like success. */
+.fp-out {
+  margin: 10px 16px 14px;
+  padding: 8px 10px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  font-size: 11px;
+  font-family: var(--font-mono);
+  color: var(--text2);
+  overflow-wrap: anywhere;
+  min-height: 30px;
+}
+
+.fp-out.fp-bad {
+  color: var(--danger, #e06c75);
+  border-color: color-mix(in srgb, var(--danger, #e06c75) 45%, var(--border));
+}
+
+/* Sidebar card: the state line under the heading, and the button that opens
+   the sheet. */
+#fp-card-status {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--text2);
+  overflow-wrap: anywhere;
+  margin: 0 0 6px;
+}