sealkeep 0.9.0 → 0.11.0

package/web/rules-view.js

@@ -15,6 +15,16 @@
   const policy = () => document.querySelector('input[name=policy]:checked').value;
 
   const MB = 1024 * 1024;
+  const COPIES_CACHE_KEY = "sealkeep.cloudCopiesView.v1";
+  // A large vault can contain thousands of stored copies. Keep the complete
+  // catalog in memory for filtering, but only create the rows a person has
+  // asked to see; each row carries controls and listeners, so eagerly painting
+  // the whole catalog can otherwise freeze the local dashboard.
+  const COPY_PAGE_SIZE = 100;
+  let copiesRefreshTimer = null;
+  let storedCopies = [];
+  let copiesVisibleLimit = COPY_PAGE_SIZE;
+  let rulesLoaded = false;
 
   const bytes = (value) => {
     if (!Number.isFinite(value) || value <= 0) return "0 B";
@@ -50,14 +60,14 @@
     const eligible = evaluation.candidates.filter((candidate) => candidate.eligible).length;
     $("effect").textContent = eligible === 0
       ? `Nothing is reclaimable under these rules right now — ${evaluation.candidates.length} archived session${evaluation.candidates.length === 1 ? " is" : "s are"} being tracked.`
-      : `${bytes(evaluation.reclaimableBytes)} across ${eligible} session${eligible === 1 ? "" : "s"} could be moved to your trash under these rules.`;
+      : `${bytes(evaluation.reclaimableBytes)} across ${eligible} session${eligible === 1 ? "" : "s"} could be freed from this machine under these rules.`;
   }
 
   function fill(evaluation) {
     // Never type over someone's hands. A refresh landing while a retention
     // number is being edited used to revert it silently, and the next click on
     // "Save these rules" then saved the old policy — the one that decides when
-    // original session files may be moved to the trash. loadCopies already
+    // original session files may be permanently reclaimed. loadCopies already
     // guards its one field this way; every field here needs the same.
     const set = (id, value) => {
       const node = $(id);
@@ -85,11 +95,31 @@
     return days === 0 ? "today" : days === 1 ? "1 day" : `${days} days`;
   };
 
+  const copyProviderName = (provider) => ({
+    vaultline: "Sealkeep Cloud",
+    gdrive: "Google Drive",
+    s3: "S3",
+    r2: "Cloudflare R2",
+    b2: "Backblaze B2",
+    gcs: "Google Cloud Storage"
+  })[provider] || provider || "unknown storage";
+
+  const copySearchText = (copy) => [copy.ref, copy.provider, copyProviderName(copy.provider)]
+    .filter(Boolean)
+    .join(" ")
+    .toLocaleLowerCase();
+
   function copyRow(copy) {
     const row = document.createElement("tr");
     const ref = document.createElement("td");
     ref.className = "path";
     ref.textContent = copy.ref;
+    if (copy.provider) {
+      const place = document.createElement("span");
+      place.className = "lastmark";
+      place.textContent = copyProviderName(copy.provider);
+      ref.append(place);
+    }
     if (copy.lastCopy) {
       const mark = document.createElement("span");
       mark.className = "lastmark";
@@ -116,6 +146,110 @@
     return row;
   }
 
+  function renderCopiesPage({ reset = false } = {}) {
+    if (reset) copiesVisibleLimit = COPY_PAGE_SIZE;
+    const filter = ($("copies-filter")?.value || "").trim().toLocaleLowerCase();
+    const matching = filter
+      ? storedCopies.filter((copy) => copySearchText(copy).includes(filter))
+      : storedCopies;
+    const visible = matching.slice(0, copiesVisibleLimit);
+    const body = $("copies-body");
+    body.textContent = "";
+    for (const copy of visible) body.append(copyRow(copy));
+
+    const table = $("copies-table");
+    const controls = $("copies-controls");
+    const count = $("copies-visible");
+    const more = $("copies-more");
+    controls.hidden = storedCopies.length === 0;
+    table.hidden = visible.length === 0;
+    if (matching.length === 0 && storedCopies.length > 0) {
+      count.textContent = `No stored copies match “${$("copies-filter").value.trim()}”.`;
+    } else if (visible.length < matching.length) {
+      count.textContent = `Showing ${visible.length.toLocaleString()} of ${matching.length.toLocaleString()} ${filter ? "matching " : ""}copies.`;
+    } else {
+      count.textContent = `${matching.length.toLocaleString()} ${filter ? "matching " : ""}${matching.length === 1 ? "copy" : "copies"}.`;
+    }
+    const remaining = Math.max(0, matching.length - visible.length);
+    more.hidden = remaining === 0;
+    more.textContent = remaining > COPY_PAGE_SIZE
+      ? `Show ${COPY_PAGE_SIZE.toLocaleString()} more`
+      : `Show remaining ${remaining.toLocaleString()}`;
+  }
+
+  const copyIdentity = (copy) => copy.copyId || `${copy.provider || "unknown"}\0${copy.ref}`;
+
+  function readCopiesCache(accountScope) {
+    if (!accountScope || typeof cacheBindingForToken !== "function") return null;
+    try {
+      const cached = JSON.parse(localStorage.getItem(COPIES_CACHE_KEY) || "null");
+      if (cached?.version !== 1 || cached.authBinding !== cacheBindingForToken(token)
+        || cached.accountScope !== accountScope || !Array.isArray(cached.copies)) return null;
+      return cached;
+    } catch { return null; }
+  }
+
+  function writeCopiesCache(data) {
+    const accountScope = data.catalog?.accountScope;
+    if (!accountScope || typeof cacheBindingForToken !== "function") return;
+    try {
+      localStorage.setItem(COPIES_CACHE_KEY, JSON.stringify({
+        version: 1,
+        authBinding: cacheBindingForToken(token),
+        accountScope,
+        copies: data.copies,
+        mode: data.mode,
+        rollingCapGb: data.rollingCapGb,
+        loadedAt: new Date().toISOString(),
+      }));
+    } catch {
+      // The live view remains correct when browser storage is disabled/full;
+      // only the warm last-complete fallback is unavailable on the next poll.
+    }
+  }
+
+  function mergeWithLastComplete(data) {
+    if (data.catalog?.complete) {
+      writeCopiesCache(data);
+      return data;
+    }
+    const cached = readCopiesCache(data.catalog?.accountScope);
+    if (!cached) return data;
+    const copies = [...data.copies];
+    const seen = new Set(copies.map(copyIdentity));
+    for (const copy of cached.copies) {
+      const identity = copyIdentity(copy);
+      if (!seen.has(identity)) { seen.add(identity); copies.push(copy); }
+    }
+    const providers = new Set(copies.map((copy) => copy.provider).filter(Boolean));
+    const mode = providers.size > 1
+      ? "mixed"
+      : providers.has("vaultline")
+        ? "managed"
+        : providers.size === 1 ? "own" : (data.mode === "none" ? cached.mode : data.mode);
+    return {
+      ...data,
+      copies,
+      mode,
+      catalog: { ...data.catalog, stale: true },
+    };
+  }
+
+  function scheduleCopiesRefresh() {
+    if (copiesRefreshTimer) clearTimeout(copiesRefreshTimer);
+    copiesRefreshTimer = setTimeout(() => {
+      copiesRefreshTimer = null;
+      // Re-entering the view calls loadCopies itself. Do not keep polling a
+      // hidden settings surface after the person has moved elsewhere.
+      if (!$('view-rules')?.hidden) void loadCopies();
+    }, 3200);
+  }
+
+  function copiesSummary(copies) {
+    const total = copies.reduce((sum, copy) => sum + copy.bytes, 0);
+    return `${copies.length} verified ${copies.length === 1 ? "copy" : "copies"} · ${bytes(total)}`;
+  }
+
   async function deleteCopy(copy, button, message) {
     // The design system's destructive pattern: the first click arms, the second
     // acts, and an armed button left alone stands down after four seconds so
@@ -133,7 +267,10 @@
     button.disabled = true;
     message.textContent = "";
     try {
-      await api(`/v1/cloud/copies/${encodeURIComponent(copy.ref)}`, {
+      const endpoint = copy.archiveId && copy.copyId
+        ? `/v1/archives/${encodeURIComponent(copy.archiveId)}/copies/${encodeURIComponent(copy.copyId)}`
+        : `/v1/cloud/copies/${encodeURIComponent(copy.ref)}`;
+      await api(endpoint, {
         method: "DELETE",
         body: JSON.stringify({ confirmLastCopy: button.dataset.last === "yes" })
       });
@@ -161,29 +298,52 @@
       $("copies-line").textContent = token
         ? `Could not read your stored copies: ${error.message}`
         : "Connect the dashboard to see what is stored off this machine.";
+      scheduleCopiesRefresh();
       return;
     }
-    const { copies, mode } = data;
+    // Old servers exposed in-flight rows here. Be defensive during upgrades:
+    // only provider-verified durable rows can count as stored copies or bytes.
+    data = {
+      ...data,
+      copies: Array.isArray(data.copies) ? data.copies.filter((copy) => copy?.state === "durable") : [],
+    };
+    data = mergeWithLastComplete(data);
+    const { copies, mode, catalog = { complete: true, status: "complete", updating: false, stale: false, error: null } } = data;
     if (mode === "none") {
+      if (copiesRefreshTimer) { clearTimeout(copiesRefreshTimer); copiesRefreshTimer = null; }
       $("copies-line").textContent = "No storage is connected to this vault, so nothing is stored off this machine. Everything you have archived lives here only.";
-      $("copies-table").hidden = true;
+      storedCopies = [];
+      renderCopiesPage({ reset: true });
       return;
     }
-    const total = copies.reduce((sum, copy) => sum + copy.bytes, 0);
-    $("copies-line").textContent = copies.length === 0
-      ? "Nothing is stored off this machine yet."
-      : `${copies.length} ${copies.length === 1 ? "copy" : "copies"} · ${bytes(total)} in your storage.`;
-    const body = $("copies-body");
-    body.textContent = "";
-    for (const copy of copies) body.append(copyRow(copy));
-    $("copies-table").hidden = copies.length === 0;
+    if (!catalog.complete) {
+      const visible = copies.length ? `${copiesSummary(copies)} visible` : "No verified copy total is available yet";
+      const kept = catalog.stale ? "Showing the last complete view." : "This is not the complete storage total.";
+      if (catalog.status === "error") {
+        $("copies-line").textContent = `${visible}. ${kept} Could not refresh Sealkeep Cloud${catalog.error ? `: ${catalog.error}.` : "."} Retrying automatically.`;
+      } else if (catalog.status === "incomplete") {
+        $("copies-line").textContent = `${visible}. ${kept} Sealkeep Cloud returned only part of the catalog; retrying automatically.`;
+      } else {
+        $("copies-line").textContent = `${visible}. ${kept} Updating Sealkeep Cloud copies…`;
+      }
+      scheduleCopiesRefresh();
+    } else {
+      if (copiesRefreshTimer) { clearTimeout(copiesRefreshTimer); copiesRefreshTimer = null; }
+      $("copies-line").textContent = copies.length === 0
+        ? "Nothing is stored off this machine yet."
+        : `${copies.length} ${copies.length === 1 ? "copy" : "copies"} · ${bytes(copies.reduce((sum, copy) => sum + copy.bytes, 0))} in your storage.`;
+    }
+    storedCopies = copies;
+    renderCopiesPage();
     if ($("cap") !== document.activeElement) $("cap").value = data.rollingCapGb == null ? "" : data.rollingCapGb;
   }
 
   function loadRules() {
+    $('save').disabled = !rulesLoaded;
+    if (!rulesLoaded) $('effect').textContent = 'Loading your saved cleanup rules. Nothing can be saved until they arrive.';
     // Show what is actually configured rather than the markup's defaults, so
     // this view never quietly disagrees with the vault it is editing.
-    api("/v1/retention").then(fill).catch((error) => {
+    api("/v1/retention").then((data) => { fill(data); rulesLoaded = true; $('save').disabled = false; }).catch((error) => {
       $("effect").textContent = token
         ? `Could not read the current rules: ${error.message}`
         : "Connect the dashboard so it can read this vault's current rules.";
@@ -191,7 +351,14 @@
   }
 
   function wire() {
+    $("copies-filter").addEventListener("input", () => renderCopiesPage({ reset: true }));
+    $("copies-more").addEventListener("click", () => {
+      copiesVisibleLimit += COPY_PAGE_SIZE;
+      renderCopiesPage();
+    });
+
     $("save").onclick = async () => {
+      if (!rulesLoaded) { $('saved').textContent = 'Saved rules have not loaded. Refresh before making changes.'; return; }
       $("save").disabled = true;
       $("saved").textContent = "Saving…";
       try {
@@ -210,7 +377,12 @@
           })
         });
         showEffect(evaluation);
-        $("saved").textContent = "Saved. The background service uses these from its next pass.";
+        const canReclaim = evaluation.policy === "archive-and-reclaim" || evaluation.policy === "manual-approval";
+        $("saved").textContent = !canReclaim
+          ? "Saved. Automatic reclaim is off; original sessions stay on this machine."
+          : evaluation.automaticReclaimEnabled
+            ? "Saved. This machine uses these rules from its next background pass."
+            : "Saved. These rules describe what is eligible, but automatic reclaim remains off on this machine. Turn it on in Settings when you are ready.";
       } catch (error) {
         $("saved").textContent = `Not saved: ${error.message}`;
       } finally {
@@ -223,7 +395,7 @@
 
     // The rolling cap is a Pro setting: the account is what enforces it, so a
     // vault without that account has nowhere real to write it.
-    api("/v1/status").then((status) => { if (status.plan === "pro") $("rolling").hidden = false; }).catch(() => {});
+    $("rolling").hidden = true; // Account-wide storage caps are managed online.
 
     $("cap-save").onclick = async () => {
       const raw = $("cap").value.trim();