agentgui 1.0.1062 → 1.0.1064

package/.gm/prd.yml

@@ -3106,18 +3106,6 @@
 - id: docstudio-cue-session-group-eyebrow
   subject: Verify ConversationList's session-group headers (Today/Yesterday/etc) use the --tr-label token + --fg-3 tone consistently, matching docstudio's uppercase letter-spaced low-opacity eyebrow label idiom
   status: pending
-- id: gc-delete-undo-trash
-  subject: No undo-after-delete (soft-delete/trash) anywhere in the confined delete surface
-  status: pending
-- id: gc-search-hit-hash-anchor
-  subject: Search-hit event anchor (focusEventI/focusEventTs) not carried in the hash - reload/Back loses highlighted line
-  status: pending
-- id: gc-settings-section-scrollspy
-  subject: Settings section anchor is deep-link-in only - scrolling never updates state.settingsSection or the URL
-  status: pending
-- id: gc-context-budget-affordance
-  subject: No context-size/token-budget affordance - only turn count and dollar cost shown, never remaining context headroom
-  status: pending
 - id: gc-expanded-body-highlight
   subject: Search-result highlighting inside expanded event bodies never highlights the matched query term
   status: pending

package/lib/http-handler.js

@@ -146,6 +146,73 @@ function isAllowRoot(realPath, allowRoots) {
   return allowRoots.some(r => (IS_WINDOWS ? r.toLowerCase() : r) === p);
 }
 
+// --- Soft-delete (trash) -----------------------------------------------
+// /api/delete moves entries into <root>/.agentgui-trash/<trashId>__<name>
+// instead of unlinking, giving a short undo window. In-memory index only
+// (server restart forfeits the undo window - acceptable since the retention
+// window itself is short and this is a convenience net on top of, not a
+// replacement for, the pre-delete ConfirmDialog). Purged after
+// TRASH_RETENTION_MS or when trashIndex grows past TRASH_MAX_ENTRIES
+// (oldest-first), so a long-running server's trash dir can't grow unbounded.
+const TRASH_DIR_NAME = '.agentgui-trash';
+const TRASH_RETENTION_MS = parseInt(process.env.AGENTGUI_TRASH_RETENTION_MS || '', 10) || 10 * 60 * 1000;
+const TRASH_MAX_ENTRIES = 200;
+const trashIndex = new Map(); // trashId -> { trashPath, originalPath, root, deletedAt }
+
+function purgeExpiredTrash() {
+  const now = Date.now();
+  for (const [id, info] of trashIndex) {
+    if (now - info.deletedAt > TRASH_RETENTION_MS) {
+      try { fs.rmSync(info.trashPath, { recursive: true, force: true }); } catch { /* already gone */ }
+      trashIndex.delete(id);
+    }
+  }
+  if (trashIndex.size > TRASH_MAX_ENTRIES) {
+    const sorted = [...trashIndex.entries()].sort((a, b) => a[1].deletedAt - b[1].deletedAt);
+    for (const [id, info] of sorted.slice(0, trashIndex.size - TRASH_MAX_ENTRIES)) {
+      try { fs.rmSync(info.trashPath, { recursive: true, force: true }); } catch {}
+      trashIndex.delete(id);
+    }
+  }
+}
+
+// Which allowed root a confined realPath lives under - the trash dir sits
+// alongside it (still inside the SAME root, so confineToRoots covers the
+// trash path too - no new unconfined surface).
+function rootFor(realPath, allowRoots) {
+  const p = IS_WINDOWS ? realPath.toLowerCase() : realPath;
+  return allowRoots.find(r => { const rr = IS_WINDOWS ? r.toLowerCase() : r; return p === rr || p.startsWith(rr + path.sep); });
+}
+
+function moveToTrash(realPath, allowRoots) {
+  purgeExpiredTrash();
+  const root = rootFor(realPath, allowRoots);
+  if (!root) { const e = new Error('not confined to an allowed root'); e.code = 'EACCES'; throw e; }
+  const trashDir = path.join(root, TRASH_DIR_NAME);
+  fs.mkdirSync(trashDir, { recursive: true });
+  const trashId = crypto.randomBytes(8).toString('hex');
+  const base = path.basename(realPath);
+  const trashPath = path.join(trashDir, trashId + '__' + base);
+  fs.renameSync(realPath, trashPath);
+  trashIndex.set(trashId, { trashPath, originalPath: realPath, root, deletedAt: Date.now() });
+  return { trashId };
+}
+
+function restoreFromTrash(trashId, allowRoots) {
+  const info = trashIndex.get(trashId);
+  if (!info) { const e = new Error('nothing to restore - the undo window has expired or this was already restored'); e.code = 'NOT_FOUND'; throw e; }
+  // Re-confine the ORIGINAL path at restore time (not trust the cached one
+  // blindly) - the allowlist itself doesn't change at runtime, but this keeps
+  // restore honoring the exact same confinement contract every other route does.
+  const conf = confineToRoots(info.originalPath, allowRoots);
+  if (!conf.ok && conf.reason !== 'not found') { const e = new Error('restore target is no longer inside an accessible folder'); e.code = 'CONFLICT'; throw e; }
+  if (fs.existsSync(info.originalPath)) { const e = new Error('a file already exists at the original location'); e.code = 'CONFLICT'; throw e; }
+  fs.mkdirSync(path.dirname(info.originalPath), { recursive: true });
+  fs.renameSync(info.trashPath, info.originalPath);
+  trashIndex.delete(trashId);
+  return { path: info.originalPath };
+}
+
 export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, PORT }) {
   // Warn operators when CORS_ORIGIN=* is combined with no PASSWORD: any
   // cross-origin page can make credentialless fetch() calls to all /api/*
@@ -690,13 +757,18 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
         if (isAllowRoot(conf.realPath, allowRoots)) { sendJSON(req, res, 403, { error: 'forbidden: cannot delete an allowed root' }); return; }
         try {
           const st = fs.lstatSync(conf.realPath);
-          if (st.isDirectory()) {
-            if (body.recursive === true) fs.rmSync(conf.realPath, { recursive: true });
-            else fs.rmdirSync(conf.realPath); // throws ENOTEMPTY unless empty
-          } else {
-            fs.unlinkSync(conf.realPath);
+          // Soft-delete: move into a confined per-root .agentgui-trash/ instead
+          // of unlinking, so the only safety net isn't confirm-before (the
+          // pre-existing ConfirmDialog) but also undo-after, matching an
+          // fsbrowse-grade file manager. A non-empty directory without
+          // recursive=true still throws ENOTEMPTY BEFORE any move happens
+          // (checked via a dry probe) to keep that existing guard's semantics.
+          if (st.isDirectory() && body.recursive !== true) {
+            const dryEntries = fs.readdirSync(conf.realPath);
+            if (dryEntries.length) { sendJSON(req, res, 409, { error: 'directory is not empty' }); return; }
           }
-          sendJSON(req, res, 200, { ok: true });
+          const trashInfo = moveToTrash(conf.realPath, allowRoots);
+          sendJSON(req, res, 200, { ok: true, trashId: trashInfo.trashId });
         } catch (err) {
           const code = err.code === 'ENOTEMPTY' ? 409 : (err.code === 'EACCES' || err.code === 'EPERM' ? 403 : (err.code === 'ENOENT' ? 404 : 400));
           sendJSON(req, res, code, { error: err.code === 'ENOTEMPTY' ? 'directory is not empty' : err.message });
@@ -704,6 +776,22 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
         return;
       }
 
+      // POST /api/restore {trashId} -> {ok, path}. Undoes a /api/delete within
+      // its retention window (trashRetentionMs, default 10 minutes) by moving
+      // the entry back from .agentgui-trash/ to its original confined path.
+      if (routePath.split('?')[0] === '/api/restore' && req.method === 'POST') {
+        let body;
+        try { body = JSON.parse((await readBody(req, 64 * 1024)).toString('utf8') || '{}'); }
+        catch (e) { sendJSON(req, res, e.code === 'TOO_LARGE' ? 413 : 400, { error: 'bad request body' }); return; }
+        try {
+          const restored = restoreFromTrash(String(body.trashId || ''), fsAllowRoots());
+          sendJSON(req, res, 200, { ok: true, path: restored.path });
+        } catch (err) {
+          sendJSON(req, res, err.code === 'NOT_FOUND' ? 404 : (err.code === 'CONFLICT' ? 409 : 400), { error: err.message });
+        }
+        return;
+      }
+
       // POST /api/mkdir {dir, name} -> {ok, path}. dir must exist inside roots.
       if (routePath.split('?')[0] === '/api/mkdir' && req.method === 'POST') {
         let body;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1062",
+  "version": "1.0.1064",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/site/app/js/app.js

@@ -51,7 +51,7 @@ const ARM_RESET_MS = 4000;
 
 // Full routable param set. Every view-defining piece of state round-trips
 // through the hash so reload and Back/forward restore the exact view.
-const HASH_KEYS = ['tab', 'sid', 'dir', 'file', 'q', 'project', 'section', 'filter', 'lsort', 'lfilter', 'lerr'];
+const HASH_KEYS = ['tab', 'sid', 'dir', 'file', 'q', 'project', 'section', 'filter', 'lsort', 'lfilter', 'lerr', 'ets'];
 function readHash() {
   const hash = location.hash || '';
   const out = {};
@@ -80,6 +80,11 @@ function buildHash() {
     const q = (state.searchQ || '').trim();
     if (q.length >= 2) parts.push('q=' + encodeURIComponent(q));
     if (state.projectFilter) parts.push('project=' + encodeURIComponent(state.projectFilter));
+    // A session opened from a search hit carries the matched event's
+    // timestamp so reload/Back reproduces the same scrolled+flashed position
+    // a live click gives - without this, the anchor only existed in memory
+    // and a search-hit URL degraded to just the bare session on reload.
+    if (state._focusEventTs != null) parts.push('ets=' + encodeURIComponent(state._focusEventTs));
   }
   if (tab === 'settings' && state.settingsSection) parts.push('section=' + encodeURIComponent(state.settingsSection));
   if (tab === 'live') {
@@ -822,7 +827,14 @@ function sessionsColumn() {
       onNew: () => { navTo('chat'); newChat(); },
       onSelect: (s) => {
         if (state.tab === 'chat') resumeInChat({ sid: s.sid });
-        else loadSession(s.sid, { focusEventI: s._focusEventI, focusEventTs: s._focusEventTs });
+        else {
+          // Persist the anchor so buildHash() can carry it into the URL -
+          // without this, reload/Back only ever restored the bare session,
+          // losing the matched event's scroll+flash position.
+          state._focusEventTs = s._focusEventTs ?? null;
+          loadSession(s.sid, { focusEventI: s._focusEventI, focusEventTs: s._focusEventTs });
+          writeHash({ push: true });
+        }
       },
       loading: state.searchBusy,
       error: state.searchHits.error || null,
@@ -1168,10 +1180,13 @@ async function runFileMutation(fn, doneMsg, patch) {
   if (!d || d.busy) return;
   d.busy = true; d.error = null; render();
   try {
-    await fn();
+    const result = await fn();
     state.files.dialog = null;
     restoreFileDialogFocus(d._trigger);
     announce(doneMsg);
+    // A soft-delete's trashId (if this mutation was a delete) rides the
+    // return value straight to the undo-toast caller.
+    if (result && result.trashId) offerUndoDelete(result.trashId, doneMsg);
     if (patch) {
       // Patch the visible list immediately, matching the bulk-delete/move
       // pattern, instead of stalling the dialog on a second full round-trip.
@@ -1188,6 +1203,36 @@ async function runFileMutation(fn, doneMsg, patch) {
     d.busy = false; d.error = fileMutationCopy(e); render();
   }
 }
+// Delete is a soft-delete server-side (moved to a confined .agentgui-trash/,
+// see lib/http-handler.js) - offer a real undo action within the retention
+// window instead of the ConfirmDialog's pre-delete confirm being the ONLY
+// safety net. One active undo toast at a time (the most recent delete wins;
+// an in-flight bulk-delete calls this per-entry, each replacing the last -
+// acceptable since restoring the single most recent one is still strictly
+// better than no undo at all, and stacking N toasts for a bulk op would be
+// its own UX problem).
+const UNDO_DELETE_WINDOW_MS = 10000;
+let _undoDeleteTimer = null;
+function offerUndoDelete(trashId, doneMsg) {
+  clearTimeout(_undoDeleteTimer);
+  state.files.undoDelete = { trashId, doneMsg };
+  render();
+  _undoDeleteTimer = setTimeout(() => { state.files.undoDelete = null; render(); }, UNDO_DELETE_WINDOW_MS);
+}
+async function undoDelete() {
+  const u = state.files.undoDelete;
+  if (!u) return;
+  clearTimeout(_undoDeleteTimer);
+  state.files.undoDelete = null;
+  try {
+    await B.restoreEntry(state.backend, u.trashId);
+    announce('restored');
+    await loadDir(state.files.path, { fromHash: true });
+  } catch (e) {
+    announce('could not restore: ' + fileMutationCopy(e));
+    render();
+  }
+}
 // Upload a FileList into the current directory; per-file rows feed the kit
 // UploadProgress (done/error per file - fetch has no chunk progress).
 async function uploadFiles(fileList) {
@@ -1322,9 +1367,12 @@ function fileDialog() {
     const isDir = d.file.type === 'dir';
     return ConfirmDialog({
       title: 'Delete ' + d.file.name,
+      // Delete is soft (moved to trash, undoable for a short window right
+      // after) - the copy no longer overclaims permanence the way an actual
+      // unlink would warrant.
       message: isDir
-        ? 'Delete this folder and everything inside it? This cannot be undone.'
-        : 'Delete this file? This cannot be undone.',
+        ? 'Delete this folder and everything inside it? You can undo this for a few seconds after.'
+        : 'Delete this file? You can undo this for a few seconds after.',
       error: d.error || null, busy: !!d.busy,
       confirmLabel: d.busy ? 'deleting…' : 'delete', cancelLabel: 'cancel', destructive: true,
       onCancel: closeFileDialog,
@@ -1647,6 +1695,10 @@ function filesMain() {
     : body;
   return [
     offlineBanner(),
+    f.undoDelete ? Alert({ key: 'undodel', kind: 'info', title: 'Deleted',
+      children: [
+        h('span', { key: 'udtxt' }, (f.undoDelete.doneMsg || 'Deleted') + ' - undo within a few seconds. '),
+        Btn({ key: 'udbtn', onClick: () => undoDelete(), children: 'undo' })] }) : null,
     PageHeader({ compact: true, dense: true, title: 'Files', lede: 'Browse and manage files in the allowed folders.' }),
     // One vertical beat (.ds-files-stack gap) for the whole command stack -
     // the bands used to butt edge-to-edge while the header gap was 24px.
@@ -3927,6 +3979,10 @@ async function loadSession(sid, { focusEventI = null, focusEventTs = null, fromH
     return;
   }
   state.selectedSid = sid;
+  // A plain (non-search-hit) session open must not carry a stale event
+  // anchor forward into the URL - only reset it when this call ISN'T itself
+  // the one supplying a fresh focusEventTs.
+  if (focusEventTs == null) state._focusEventTs = null;
   state.events = [];
   state.events._seen = new Set();     // O(1) dedupe by event index
   state.eventsLoaded = false;
@@ -4092,9 +4148,11 @@ async function init() {
   } else if (hp.sid) {
     if (hp.q) state.searchQ = hp.q;
     if (hp.project) state.projectFilter = hp.project;
+    const bootFocusTs = hp.ets != null ? Number(hp.ets) : null;
+    if (bootFocusTs != null && !Number.isNaN(bootFocusTs)) state._focusEventTs = bootFocusTs;
     navTo('history', { push: false });
     await refreshHistory();
-    await loadSession(hp.sid, { fromHash: true });
+    await loadSession(hp.sid, { fromHash: true, focusEventTs: bootFocusTs != null && !Number.isNaN(bootFocusTs) ? bootFocusTs : undefined });
     if (state.searchQ.trim().length >= 2) runSearch();
   } else if (bootTab !== state.tab) {
     // Files deep-link: restore the directory the URL names (reload keeps
@@ -4119,6 +4177,7 @@ async function init() {
   }
 
   registerWsStatusOnce();
+  registerSettingsScrollSpyOnce();
   startActivePolling();   // surface running chats on any tab, not just history
   startRelTimeTick();
   startLiveTick();        // 1s elapsed advance on the live dashboard
@@ -4177,6 +4236,44 @@ function focusSettingsSection(id) {
     el.addEventListener('blur', clear);
   });
 }
+const SETTINGS_SECTION_IDS = ['backend', 'server', 'agents', 'appearance', 'keyboard', 'data'];
+// Settings was deep-link-IN only: focusSettingsSection() (a section= URL param
+// or the ?-overlay jump) set state.settingsSection, but manually scrolling
+// never updated it back - so the URL/state silently went stale the instant a
+// user scrolled by hand, and Back could never step BETWEEN panels the way it
+// does for every other tab. A lightweight scroll-position scrollspy (not a
+// full IntersectionObserver - the settings scroll region is small/short-lived
+// enough that a debounced scroll-position check is simpler and avoids the
+// observer-lifecycle bookkeeping) keeps state.settingsSection (and the URL)
+// honest while the user scrolls, registered once like the WS/session-expired
+// listeners above.
+const debouncedSettingsScrollSpy = debounce(() => {
+  if (state.tab !== 'settings') return;
+  const region = document.querySelector('#agentgui-main');
+  if (!region) return;
+  const regionTop = region.getBoundingClientRect().top;
+  let current = null;
+  for (const id of SETTINGS_SECTION_IDS) {
+    const el = document.getElementById(id);
+    if (!el) continue;
+    // The section whose top has scrolled past the region's own top edge
+    // (with a little slack for the sticky header) is the "current" one -
+    // same heuristic every scrollspy implementation uses.
+    if (el.getBoundingClientRect().top - regionTop <= 80) current = id;
+  }
+  if (current && current !== state.settingsSection) {
+    state.settingsSection = current;
+    writeHash({ push: false });   // passive sync, not a Back-able step - matches search text/filter's replaceState treatment
+  }
+}, 150);
+let settingsScrollSpyRegistered = false;
+function registerSettingsScrollSpyOnce() {
+  if (settingsScrollSpyRegistered) return;
+  settingsScrollSpyRegistered = true;
+  document.addEventListener('scroll', (e) => {
+    if (e.target && e.target.id === 'agentgui-main') debouncedSettingsScrollSpy();
+  }, true);   // capture: #agentgui-main itself is the scrolling element, not a bubling target
+}
 
 // Browser Back/forward: diff the FULL hash param set against state and re-sync
 // each piece. Everything here runs with writeHash:false / fromHash:true so the
@@ -4189,7 +4286,11 @@ window.addEventListener('popstate', () => {
   // anything else - or a bare sid - opens it in history).
   if (hp.sid && hp.sid !== state.selectedSid) {
     if (tab === 'chat') resumeInChat({ sid: hp.sid }, { fromHash: true });
-    else loadSession(hp.sid, { fromHash: true });
+    else {
+      const popFocusTs = hp.ets != null ? Number(hp.ets) : null;
+      state._focusEventTs = (popFocusTs != null && !Number.isNaN(popFocusTs)) ? popFocusTs : null;
+      loadSession(hp.sid, { fromHash: true, focusEventTs: (popFocusTs != null && !Number.isNaN(popFocusTs)) ? popFocusTs : undefined });
+    }
   } else if (!hp.sid && state.selectedSid && tab === 'history') {
     state.selectedSid = null;
     state.events = [];

package/site/app/js/backend.js

@@ -167,7 +167,10 @@ export async function statPath(base, p) {
 }
 
 export function renameEntry(base, filePath, newName) { return mutateJSON(base, '/api/rename', { path: filePath, newName }); }
+// deleteEntry's server response now includes trashId - the delete is a soft
+// move-to-trash, not a permanent unlink, so the caller can offer an undo.
 export function deleteEntry(base, filePath, recursive) { return mutateJSON(base, '/api/delete', { path: filePath, recursive: !!recursive }); }
+export function restoreEntry(base, trashId) { return mutateJSON(base, '/api/restore', { trashId }); }
 export function makeDir(base, dirPath, name) { return mutateJSON(base, '/api/mkdir', { dir: dirPath, name }); }
 export function moveEntry(base, filePath, destDir, overwrite) { return mutateJSON(base, '/api/move', { path: filePath, destDir, overwrite: !!overwrite }); }