agentgui 1.0.1063 → 1.0.1064

package/.gm/prd.yml

@@ -3106,9 +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-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.1063",
+  "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

@@ -1180,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.
@@ -1200,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) {
@@ -1334,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,
@@ -1659,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.

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 }); }