aegis-desktop 0.6.1 → 0.7.0

package/main.js

@@ -66,6 +66,7 @@ const ollama = require('./lib/local/ollama.js');
 const providers = require('./lib/local/providers.js');
 const sessionStore = require('./lib/sync/sessions.js');
 const memoryQueue = require('./lib/sync/memory-queue.js');
+const persistGate = require('./lib/sync/persist-gate.js');
 const windowState = require('./lib/window-state.js');
 const deepLink = require('./lib/deep-link.js');
 const quickLauncherLib = require('./lib/quick-launcher.js');
@@ -829,6 +830,62 @@ function createEngine(aegis, { app, safeStorage, dir: dirOverride, sessionsDir:
   return { engine, sessionsDir, settingsDir, settings };
 }
 
+/** Largest pre-edit read the diff bridge will hand the renderer (bytes). */
+const PREVIEW_READ_MAX_BYTES = 512 * 1024;
+
+/**
+ * The contained, capped read behind the renderer's diff preview — the only
+ * filesystem capability the renderer has, and the narrowest form of it.
+ *
+ * The renderer supplies a file plus the cwd of the session it is displaying.
+ * Every path is resolved with `realpath` *before* the containment test, so a
+ * symlink planted inside the workspace cannot point the read outside it, and
+ * containment is judged with `path.relative` rather than a `startsWith` prefix
+ * (which would let `/home/neo-evil` pass a naive `/home/neo` check). Anything
+ * refused — relative cwd, escape, missing file, directory, non-regular file —
+ * returns null, which degrades the preview to a create-style diff instead of
+ * throwing onto the render path.
+ *
+ * @returns {{text: string, truncated: boolean}|null}
+ */
+function readTextFileForPreview(payload) {
+  try {
+    const file = payload && typeof payload.file === 'string' ? payload.file : '';
+    const cwd = payload && typeof payload.cwd === 'string' ? payload.cwd : '';
+    if (!file || !cwd || !path.isAbsolute(cwd)) return null;
+
+    // realpath both sides: resolving the root too keeps this correct on hosts
+    // where the workspace itself is reached through a symlink (/tmp, /var).
+    const root = fs.realpathSync(cwd);
+    const abs = fs.realpathSync(path.resolve(root, file));
+    const rel = path.relative(root, abs);
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+
+    const st = fs.statSync(abs);
+    if (!st.isFile()) return null;
+
+    if (st.size <= PREVIEW_READ_MAX_BYTES) {
+      return { text: fs.readFileSync(abs, 'utf8'), truncated: false };
+    }
+    // Oversized: read only the head of the file and cut back to the last
+    // newline, so a byte-boundary truncation cannot leave a half-decoded
+    // multi-byte sequence at the end of the preview.
+    const fd = fs.openSync(abs, 'r');
+    try {
+      const buf = Buffer.alloc(PREVIEW_READ_MAX_BYTES);
+      const n = fs.readSync(fd, buf, 0, PREVIEW_READ_MAX_BYTES, 0);
+      let text = buf.toString('utf8', 0, n);
+      const nl = text.lastIndexOf('\n');
+      if (nl > 0) text = text.slice(0, nl + 1);
+      return { text, truncated: true };
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Pure mapping: model:<name> -> LocalEngine call (unit-testable in Node).
  */
@@ -849,6 +906,14 @@ function createModelDispatch(engine) {
       }),
     'settings.remove': (payload) =>
       engine.settings.remove(payload && payload.provider),
+    // Persisting memory ("sync finished turns to cloud memory automatically").
+    // Reserved namespace, so it is invisible to the provider CRUD above — but
+    // unlike a provider it IS reachable deliberately, through these two. The
+    // gate that enforces it lives in lib/sync/persist-gate.js and reads the
+    // same file, so a `false` written here stops the next automatic push.
+    'memoryPersist.get': () => engine.settings.memoryPersistState(),
+    'memoryPersist.set': (payload) =>
+      engine.settings.setMemoryPersist(Boolean(payload && payload.enabled)),
     cancel: (payload) => engine.cancel(payload && payload.sessionId),
     // Tool-call approval gate (desktop/lib/local/engine.js gatedExecuteTool):
     // the renderer's approval card answers a pending exec/writeFile/editFile
@@ -869,7 +934,7 @@ function createModelDispatch(engine) {
  * resolve `{ ok: false, reason }` without ever throwing, and every local
  * flow (save/append/list) keeps working untouched.
  */
-function createSyncDispatch(sessions, dir, aegis) {
+function createSyncDispatch(sessions, dir, aegis, settingsDir) {
   let lastSyncAt = null;
 
   function hasCloud() {
@@ -1013,7 +1078,20 @@ function createSyncDispatch(sessions, dir, aegis) {
     }
   }
 
+  // The automatic post-turn push (persisting memory for every account). Gated
+  // by the `__memoryPersist` preference in settings.json, which the Settings
+  // pane writes through the memoryPersist:* IPC below; the gate is read from
+  // disk in the main process so the renderer cannot push past it. This must
+  // read `settingsDir` (Electron's userData path), NOT `dir` — `dir` here is
+  // the shared aegisHome() sessions/credentials directory, a different path
+  // from userData in a real install, and the settings store is created with
+  // `settingsDir`. Falling back to `dir` only covers callers (tests) that
+  // never pass `settingsDir` and use one directory for everything.
+  const autoPush = persistGate.createAutoPush({ push, dir: settingsDir || dir });
+
   return {
+    auto: () => autoPush.auto(),
+    memoryPersistState: () => autoPush.gate(),
     listSessions: () => ({ sessions: sessions.listSessions(dir) }),
     open: (payload) => sessions.getSession(dir, payload && payload.sessionId),
     save: (payload) => sessions.upsertSession(dir, payload || {}),
@@ -1135,11 +1213,16 @@ function createHeartbeatRetry(push, opts = {}) {
  * `onReplyFinished`, like the identical param on registerIpc, is
  * bootstrap()-only — it fires the native "reply ready" notification when the
  * window is unfocused/hidden and is never set in the headless test path.
- * `heartbeatOpts` ({ now, baseMs, maxMs }) is for tests only.
+ * `heartbeatOpts` ({ now, baseMs, maxMs }) is for tests only. `settingsDir`
+ * is Electron's userData path — where settings.json (and so the
+ * `__memoryPersist` preference the auto-push gate reads) actually lives;
+ * `sessionsDir` is the separate shared aegisHome() directory and must not be
+ * used for that gate. Falls back to `sessionsDir` for callers that don't pass
+ * it, i.e. tests that use one directory for everything.
  */
-function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished, heartbeatOpts) {
+function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished, heartbeatOpts, settingsDir) {
   const modelDispatch = createModelDispatch(engine);
-  const syncDispatch = createSyncDispatch(sessionStore, sessionsDir, aegis);
+  const syncDispatch = createSyncDispatch(sessionStore, sessionsDir, aegis, settingsDir);
 
   const heartbeat = createHeartbeatRetry(() => syncDispatch.push(), heartbeatOpts);
 
@@ -1187,6 +1270,17 @@ function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished,
     ipcMain.handle(`${MODEL_PREFIX}${name}`, (_event, payload) => handler(payload));
   }
 
+  // Diff-preview pre-edit read (preload.js `readTextFile`). Registered with
+  // `on` + `event.returnValue`, NOT `handle`: the bridge is `sendSync` because
+  // editPreview consumes its reader synchronously and cannot await an invoke
+  // promise, and `sendSync` is answered only by an `ipcMain.on` listener.
+  // Putting it in modelDispatch above would register a `handle` that sendSync
+  // never reaches. Fires on every edit tool's run frame, so the refusal path
+  // is the common case (a `writeFile` creating a new file) and must stay cheap.
+  ipcMain.on(`${MODEL_PREFIX}readTextFile`, (event, payload) => {
+    event.returnValue = readTextFileForPreview(payload);
+  });
+
   for (const [name, handler] of Object.entries(syncDispatch)) {
     if (name === 'status') {
       ipcMain.handle(`${SYNC_PREFIX}${name}`, (_event, payload) => {
@@ -2181,7 +2275,7 @@ function bootstrap() {
   // One settings store backs both the provider settings surface and the AEGIS
   // API key entry. It lives only in the main process and encrypts keys at rest
   // via Electron safeStorage (best-effort base64 when unavailable).
-  const { engine, sessionsDir, settings } = createEngine(aegis, {
+  const { engine, sessionsDir, settingsDir, settings } = createEngine(aegis, {
     app,
     safeStorage,
     dir: dataDir,
@@ -2233,7 +2327,15 @@ function bootstrap() {
     (url) => shell.openExternal(url),
     notifyReplyIfUnfocused
   );
-  registerModelIpc(ipcMain, engine, sessionsDir, aegis, notifyReplyIfUnfocused);
+  registerModelIpc(
+    ipcMain,
+    engine,
+    sessionsDir,
+    aegis,
+    notifyReplyIfUnfocused,
+    undefined,
+    settingsDir
+  );
 
   // Tool-call approval toggle (Settings → "Confirm before running tools"):
   // aegis:getConfirmMode / aegis:setConfirmMode. Registered here because this
@@ -2611,6 +2713,8 @@ module.exports = {
   taggedChunk,
   maskKey,
   createModelDispatch,
+  readTextFileForPreview,
+  PREVIEW_READ_MAX_BYTES,
   createSyncDispatch,
   registerModelIpc,
   createHeartbeatRetry,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",
@@ -29,7 +29,7 @@
     "icon": "node scripts/generate-icon.mjs",
     "dist": "npm run predist && electron-builder",
     "dist:dir": "npm run predist && electron-builder --dir",
-    "check": "node --check main.js && node --check preload.js && node --check renderer/app.js && node --check renderer/quick.js && node --check renderer/budget.js && node --check renderer/usage.js && node --check renderer/stream-policy.js && node --check renderer/transcript-view.js && node --check renderer/markdown.js && node --check renderer/vendor/aegis-highlight.js && node --check scripts/predist.mjs && node --check scripts/generate-icon.mjs && node --check lib/local/context.js && node --check lib/local/providers.js && node --check lib/local/ollama.js && node --check lib/local/engine.js && node --check lib/local/session-rounds.js && node --check lib/local/tools.js && node --check lib/local/prompt.js && node --check lib/local/shell.js && node --check lib/local/agents.js && node --check lib/local/queue.js && node --check lib/local/autonomous.js && node --check lib/settings.js && node --check lib/sync/sessions.js && node --check lib/sync/memory-queue.js && node --check lib/window-state.js && node --check lib/deep-link.js && node --check lib/quick-launcher.js && node --check bin/aegis.js",
+    "check": "node --check main.js && node --check preload.js && node --check renderer/app.js && node --check renderer/quick.js && node --check renderer/budget.js && node --check renderer/usage.js && node --check renderer/stream-policy.js && node --check renderer/transcript-view.js && node --check renderer/diff.js && node --check renderer/diffview.js && node --check renderer/markdown.js && node --check renderer/vendor/aegis-highlight.js && node --check scripts/predist.mjs && node --check scripts/generate-icon.mjs && node --check lib/local/context.js && node --check lib/local/providers.js && node --check lib/local/ollama.js && node --check lib/local/engine.js && node --check lib/local/session-rounds.js && node --check lib/local/tools.js && node --check lib/local/prompt.js && node --check lib/local/shell.js && node --check lib/local/agents.js && node --check lib/local/queue.js && node --check lib/local/autonomous.js && node --check lib/settings.js && node --check lib/sync/sessions.js && node --check lib/sync/memory-queue.js && node --check lib/window-state.js && node --check lib/deep-link.js && node --check lib/quick-launcher.js && node --check bin/aegis.js",
     "test:shell": "node ../test/desktop-shell.mjs",
     "test:model": "node ../test/model-dispatch.mjs",
     "test:budget": "node ../test/budget.test.mjs",
@@ -39,6 +39,8 @@
     "test:highlight": "node ../test/aegis-highlight.test.mjs",
     "test:markdown": "node ../test/markdown.test.mjs",
     "test:deep-link": "node test/deep-link.test.mjs",
+    "test:renderer-diff": "node test/renderer-diff.test.mjs",
+    "test:preview-read": "node ../test/desktop-preview-read.test.mjs",
     "test:stream-policy": "node ../test/stream-policy.test.mjs",
     "test:renderer-dom": "node ../test/renderer-dom.test.mjs",
     "test:renderer-wiring": "node ../test/renderer-wiring.test.mjs"

package/preload.js

@@ -102,6 +102,26 @@ const api = {
   billingCheckout: () => invoke('billingCheckout'),
   tokenBankTopup: (amountEur) => invoke('tokenBankTopup', { amountEur }),
   listModels: () => invoke('listModels'),
+  // Pre-edit file read for the diff preview (renderer/deriveDiff). A Write's
+  // preview needs the file's contents as they were *before* the executor
+  // overwrites them, and editPreview consumes a reader synchronously — so this
+  // one method is sentSync, not invoke. It is the narrowest possible widening
+  // of the bridge: main constrains the path to inside `cwd` and caps the read
+  // (main.js readTextFileForPreview), so the renderer can only ever reach files
+  // the session it is displaying is already allowed to edit. Returns
+  // `{ text, truncated }` or null; a bridge failure reports null rather than
+  // throwing onto the render path, which degrades the diff to a create-style
+  // "all additions" block.
+  readTextFile: (file, cwd) => {
+    try {
+      return ipcRenderer.sendSync(MODEL_PREFIX + 'readTextFile', {
+        file,
+        cwd,
+      });
+    } catch {
+      return null;
+    }
+  },
   // Streaming chat (D2.1): pass an onDelta callback to receive SSE chunks as
   // they arrive (pushed from main over aegis:chatDelta). The invoke promise
   // resolves once with the normalised final result. Without a callback the
@@ -149,6 +169,11 @@ const api = {
   // call. Both resolve `{ enabled }`.
   getConfirmMode: () => invoke('getConfirmMode'),
   setConfirmMode: (enabled) => invoke('setConfirmMode', { enabled: Boolean(enabled) }),
+  // Persisting memory (the desktop counterpart of the CLI's `memoryPersist`):
+  // whether a finished turn is pushed to cloud memory automatically. Default
+  // ON; `source` distinguishes a stored preference from that default.
+  getMemoryPersist: () => invoke('memoryPersist.get'),
+  setMemoryPersist: (enabled) => invoke('memoryPersist.set', { enabled: Boolean(enabled) }),
 
   // Auto-update (electron-updater over GitHub Releases — see main.js
   // createUpdateManager). check/download resolve the same status shape the
@@ -276,6 +301,12 @@ const sync = {
   push: () => invokeSync('push'),
   pull: () => invokeSync('pull'),
   status: () => invokeSync('status'),
+  // The automatic post-turn push ("persisting memory"). Gate-checked in main
+  // against the `__memoryPersist` preference, so calling this on every turn is
+  // cheap when persistence is off — it returns `{ skipped: true }` without
+  // opening a request. `memoryPersistState()` reports the gate itself.
+  auto: () => invokeSync('auto'),
+  memoryPersistState: () => invokeSync('memoryPersistState'),
 };
 
 // Quick launcher surface: loaded by BOTH renderer/index.html (the settings

package/renderer/app.js

@@ -1940,7 +1940,7 @@ async function spawnPath(card, spec) {
       // tool executes. This line is retrospective by design (see
       // toolActivityLabel), so acting on the run frame too would print every
       // tool twice — once when it starts, once when it finishes.
-      if (chunk.tool.phase === 'run') return;
+      if (chunk.tool.phase === 'run') { captureDiffPreview(chunk.tool); return; }
       appendToolActivity(card, chunk.tool, 'flow-tools', '.flow-body');
       return;
     }
@@ -2116,6 +2116,54 @@ function setBusy(busy, { cancellable } = {}) {
  */
 const TOOL_LABEL_MAX = 72;
 
+/**
+ * Host tool names whose calls render as a collapsible diff block instead of a
+ * bare line. The engine's own spellings (`Edit`/`Write`/`MultiEdit`) are
+ * included so a frame from a newer engine renders the same rather than falling
+ * back to a plain row.
+ */
+const EDIT_TOOL_NAMES = new Set(['editFile', 'writeFile', 'Edit', 'Write', 'MultiEdit']);
+
+/**
+ * Diff previews captured on a tool's `phase: 'run'` frame, keyed by tool id.
+ * The run frame fires strictly before the executor writes, which is the only
+ * moment a `writeFile`'s pre-edit contents can still be read — so the preview
+ * is built there and replayed when the matching `done` frame arrives.
+ */
+const toolPreviews = new Map();
+
+/**
+ * The pre-edit read a `writeFile`/`Write` preview needs. The renderer runs
+ * sandboxed (main.js sets contextIsolation + sandbox, so there is no
+ * `node:fs`), so the read goes over the preload bridge's synchronous
+ * `readTextFile`. Main confines the path to the session cwd it is handed, so
+ * `cwd` must travel with the call — without it main has nothing to contain
+ * against and refuses, which degrades the write to a create-style diff (all
+ * additions). `editFile` carries its own old_string and needs no read, so it
+ * always renders a full diff regardless.
+ */
+function hostReadFile(file, cwd) {
+  try {
+    const bridge = typeof window !== 'undefined' ? window.aegis : null;
+    if (bridge && typeof bridge.readTextFile === 'function') {
+      return bridge.readTextFile(file, cwd);
+    }
+  } catch {
+    // A bridge that throws must not break the render path.
+  }
+  return undefined;
+}
+
+/** Build and stash the diff preview for an edit tool when its run frame arrives. */
+function captureDiffPreview(tool) {
+  if (!tool || !EDIT_TOOL_NAMES.has(tool.name) || tool.id == null) return;
+  // editPreview calls readFile(file) with no cwd, so bind the frame's cwd here.
+  const cwd = tool.cwd;
+  const readFile = (file) => hostReadFile(file, cwd);
+  const preview = editPreview(tool.name, tool.args, { cwd, readFile });
+  if (preview) toolPreviews.set(tool.id, preview);
+}
+
 /**
  * One display line for a completed tool call (`onDelta`'s `{ tool: {name,
  * args, ok} }` chunk — see desktop/lib/local/engine.js). Fires after the tool
@@ -2141,7 +2189,12 @@ function toolActivityLabel(tool) {
   return `→ ${name}${shown ? ` ${shown}` : ''} ${mark}`;
 }
 
-/** Append one tool-activity line to `row`, creating the container on first use. */
+/**
+ * Append one tool-activity line to `row`, creating the container on first use.
+ * An edit tool whose preview was captured on its run frame renders as a
+ * collapsible diff block in place of the bare line; every other tool keeps the
+ * plain `→ name path ✓` row.
+ */
 function appendToolActivity(row, tool, containerClass, beforeSelector) {
   if (!row) return;
   let toolsEl = row.querySelector(`.${containerClass}`);
@@ -2152,6 +2205,15 @@ function appendToolActivity(row, tool, containerClass, beforeSelector) {
     if (before) row.insertBefore(toolsEl, before);
     else row.appendChild(toolsEl);
   }
+  const preview = tool && tool.id != null ? toolPreviews.get(tool.id) : null;
+  if (preview) {
+    toolPreviews.delete(tool.id); // one-shot: a stale id must not replay on a retry
+    const block = renderDiffBlock(preview, document);
+    if (block) {
+      toolsEl.appendChild(block);
+      return toolsEl;
+    }
+  }
   const line = document.createElement('div');
   line.textContent = toolActivityLabel(tool);
   toolsEl.appendChild(line);
@@ -2695,6 +2757,41 @@ async function refreshSyncStatus() {
 /** Explicit "Sync now" — push pending sessions, then pull remote ones.
  *  Offline-first: sync.push()/sync.pull() resolve `{ ok:false, reason }`
  *  rather than throwing, so this only hits the catch on an unexpected error. */
+/**
+ * Persisting memory after a turn: ask main to push what just finished.
+ *
+ * Deliberately unawaited — the answer is already on screen and in the local
+ * session store, so cloud memory is strictly extra and the composer must come
+ * back the moment the answer lands, not after a round trip. The decision to
+ * push at all is main's (lib/sync/persist-gate.js reads the `__memoryPersist`
+ * preference off disk and returns `{ skipped: true }` when it is off); this is
+ * a request, not a gate, which is why no preference is read here.
+ *
+ * It cannot throw — createAutoPush resolves on every failure — but the
+ * `.catch` stays: an unhandled rejection in the renderer is how a background
+ * convenience turns into a fatal.
+ */
+function autoPersistTurn() {
+  if (typeof sync.auto !== 'function') return;
+  sync
+    .auto()
+    .then((result) => {
+      // Same notice as syncNow(): the cap is the one sync outcome the user
+      // must see rather than have silently absorbed.
+      if (result && result.upgrade) {
+        capNotice(
+          els.sessionsHint,
+          result.upgrade,
+          'queued memory is waiting on the free-plan cap',
+          'Upgrade to sync it →'
+        );
+      }
+    })
+    .catch(() => {
+      /* persistence is non-fatal */
+    });
+}
+
 async function syncNow() {
   els.syncNow.disabled = true;
   els.sessionsHint.textContent = 'syncing…';
@@ -2936,7 +3033,7 @@ async function send() {
       // row. Ignored here, and ignored *before* `toolLog.push` — a run frame
       // counted as a completed tool would inflate the turn summary's tool
       // count for a call that hasn't run yet.
-      if (chunk.tool.phase === 'run') return;
+      if (chunk.tool.phase === 'run') { captureDiffPreview(chunk.tool); return; }
       toolLog.push(chunk.tool);
       const row = ensurePendingRow();
       row.classList.remove('pending');
@@ -2985,6 +3082,9 @@ async function send() {
       /* persistence is non-fatal */
     }
 
+    // Persisting memory: the finished turn goes to the cloud on its own now.
+    autoPersistTurn();
+
     // The AI's second path: not awaited — the lane streams beside the thread
     // while the composer goes straight back to the user (chat flow D2.2).
     if (exploreEnabled() && text !== '(empty response)') {
@@ -3005,6 +3105,10 @@ async function send() {
       } catch {
         /* persistence is non-fatal */
       }
+      // A stopped turn is persisted too, and on purpose: this is the case a
+      // round-horizon stop produces (the model was cut off mid-work), and the
+      // partial transcript is exactly what the next turn needs restored.
+      autoPersistTurn();
     } else {
       addMessage(
         'assistant',