pinokiod 8.0.64 → 8.0.66

package/kernel/vault/index.js

@@ -1494,7 +1494,7 @@ class Vault {
     }
   }
 
-  async startFolderDiscovery(selectedRoot) {
+  async startFolderDiscovery(selectedRoot, selectedThreshold) {
     if (!this.enabled || !this.folderFinder) {
       return { started: false, disabled: true }
     }
@@ -1509,6 +1509,9 @@ class Vault {
         !path.isAbsolute(selectedRoot.trim())) {
       return { error: "Choose a valid folder or drive." }
     }
+    if (!CANDIDATE_SIZE_OPTIONS.includes(selectedThreshold)) {
+      return { error: "Choose a valid minimum file size." }
+    }
     if (this.scanPromise) {
       return { error: "Wait for the current scan to finish." }
     }
@@ -1520,10 +1523,15 @@ class Vault {
       return { error: "Run a global scan before finding folders." }
     }
     const publishedThreshold = Number(globalScan.candidate_min_bytes)
-    const threshold = Number.isFinite(publishedThreshold) &&
-      publishedThreshold >= 0
-      ? publishedThreshold
-      : this.sizeThreshold
+    if (!Number.isFinite(publishedThreshold) || publishedThreshold < 0) {
+      return { error: "Run a new global scan before finding folders." }
+    }
+    if (selectedThreshold < publishedThreshold) {
+      return {
+        error: "Run a global scan with this minimum file size before searching folders."
+      }
+    }
+    const threshold = selectedThreshold
     const partial = !!globalScan.partial || (
       Array.isArray(globalScan.exclusions) &&
       globalScan.exclusions.length > 0
@@ -1832,7 +1840,10 @@ class Vault {
       case "cancel_scan":
         return this.cancelScan()
       case "find_folders":
-        return this.startFolderDiscovery(payload.path)
+        return this.startFolderDiscovery(
+          payload.path,
+          payload.candidate_size
+        )
       case "cancel_find_folders":
         return this.cancelFolderDiscovery()
       case "clear_find_folders":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.64",
+  "version": "8.0.66",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/public/app-vault-mode.js

@@ -5,6 +5,25 @@
   const app = status.dataset.app || ""
   const tab = status.closest("#save-space-tab")
   const label = status.querySelector("[data-app-vault-mode-label]")
+  const origin = window.location.origin
+  let parentStateVersion = 0
+  let fallbackTimer = null
+
+  const normalizeSnapshot = (snapshot) => ({
+    global_scan_ready: !!(snapshot && snapshot.global_scan_ready === true),
+    settings: snapshot && Array.isArray(snapshot.settings)
+      ? snapshot.settings.filter((setting) =>
+        setting && typeof setting.app === "string" && setting.app).map((setting) => ({
+          app: setting.app,
+          mode: setting.mode === "manual" ? "manual" : "automatic"
+        }))
+      : []
+  })
+  let latestSnapshot = normalizeSnapshot({
+    global_scan_ready: status.dataset.ready === "true",
+    settings: [{ app, mode: status.dataset.mode }]
+  })
+
   const setState = (value, ready) => {
     const mode = value === "manual" ? "manual" : "automatic"
     const globalScanReady = ready === true
@@ -24,23 +43,104 @@
     }
   }
   const applySnapshot = (snapshot) => {
-    const settings = snapshot && Array.isArray(snapshot.settings)
-      ? snapshot.settings
-      : []
-    const setting = settings.find((item) => item && item.app === app)
-    setState(setting && setting.mode,
-      snapshot && snapshot.global_scan_ready === true)
+    latestSnapshot = normalizeSnapshot(snapshot)
+    const setting = latestSnapshot.settings.find((item) =>
+      item.app === app)
+    setState(setting && setting.mode, latestSnapshot.global_scan_ready)
+  }
+  const vaultFrame = () =>
+    document.querySelector('iframe[name="app-vault"]')
+  const sendSnapshot = (targetWindow) => {
+    if (!targetWindow) return
+    try {
+      targetWindow.postMessage({
+        e: "vault-automatic-scan-state",
+        snapshot: latestSnapshot
+      }, origin)
+    } catch (_) {}
+  }
+  const relaySnapshot = () => {
+    const frame = vaultFrame()
+    if (frame) sendSnapshot(frame.contentWindow)
+  }
+  const mergeMode = (mode) => {
+    const settings = latestSnapshot.settings.filter((setting) =>
+      setting.app !== app)
+    settings.push({
+      app,
+      mode: mode === "manual" ? "manual" : "automatic"
+    })
+    applySnapshot({
+      global_scan_ready: latestSnapshot.global_scan_ready,
+      settings
+    })
+  }
+  const loadState = async () => {
+    if (!app) return
+    const requestedAtParentVersion = parentStateVersion
+    try {
+      const response = await fetch("/info/vault/automatic-scans", {
+        credentials: "same-origin",
+        cache: "no-store"
+      })
+      if (!response.ok) return
+      const snapshot = await response.json()
+      if (window.parent !== window &&
+          parentStateVersion !== requestedAtParentVersion) return
+      applySnapshot(snapshot)
+      relaySnapshot()
+    } catch (_) {}
   }
 
   setState(status.dataset.mode, status.dataset.ready === "true")
-  if (!app || typeof window.EventSource !== "function") return
+  if (!app) return
+
+  window.addEventListener("message", (event) => {
+    if (!event || event.origin !== origin ||
+        !event.data || typeof event.data !== "object") return
+    if (event.data.e === "vault-automatic-scan-state" &&
+        window.parent !== window && event.source === window.parent) {
+      parentStateVersion += 1
+      if (fallbackTimer !== null) {
+        window.clearTimeout(fallbackTimer)
+        fallbackTimer = null
+      }
+      applySnapshot(event.data.snapshot)
+      relaySnapshot()
+      return
+    }
+    const frame = vaultFrame()
+    if (!frame || frame.contentWindow !== event.source) return
+    if (event.data.e === "vault-automatic-scan-state-request") {
+      sendSnapshot(event.source)
+      return
+    }
+    if (event.data.e === "vault-automatic-mode-changed" &&
+        event.data.app === app) {
+      mergeMode(event.data.mode)
+      if (window.parent !== window) {
+        try {
+          window.parent.postMessage({
+            e: "vault-automatic-mode-changed",
+            app,
+            mode: status.dataset.mode
+          }, origin)
+        } catch (_) {}
+      }
+    }
+  })
 
-  const source = new window.EventSource(
-    "/info/vault/automatic-scans/events")
-  source.onmessage = (event) => {
+  if (window.parent !== window) {
     try {
-      applySnapshot(JSON.parse(event.data))
+      window.parent.postMessage({
+        e: "vault-automatic-scan-state-request"
+      }, origin)
     } catch (_) {}
+    fallbackTimer = window.setTimeout(() => {
+      fallbackTimer = null
+      loadState()
+    }, 500)
+  } else {
+    loadState()
   }
-  window.addEventListener("beforeunload", () => source.close(), { once: true })
 })()

package/server/public/layout.js

@@ -485,6 +485,70 @@
     });
   }
 
+  let latestAutomaticScanState = null;
+
+  function automaticScanState(snapshot) {
+    const settings = snapshot && Array.isArray(snapshot.settings)
+      ? snapshot.settings.filter((setting) =>
+        setting && typeof setting.app === 'string' && setting.app).map((setting) => ({
+          app: setting.app,
+          mode: setting.mode === 'manual' ? 'manual' : 'automatic',
+        }))
+      : [];
+    return {
+      global_scan_ready: !!(snapshot && snapshot.global_scan_ready === true),
+      settings,
+    };
+  }
+
+  function sendAutomaticScanState(targetWindow) {
+    if (!targetWindow || !latestAutomaticScanState) {
+      return;
+    }
+    try {
+      targetWindow.postMessage({
+        e: 'vault-automatic-scan-state',
+        snapshot: latestAutomaticScanState,
+      }, window.location.origin);
+    } catch (_) {}
+  }
+
+  function broadcastAutomaticScanState(snapshot) {
+    latestAutomaticScanState = automaticScanState(snapshot);
+    leafElements.forEach((entry) => {
+      sendAutomaticScanState(entry.iframe?.contentWindow || null);
+    });
+  }
+
+  function isLeafWindow(sourceWindow) {
+    if (!sourceWindow) return false;
+    for (const entry of leafElements.values()) {
+      if (entry.iframe && entry.iframe.contentWindow === sourceWindow) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function mergeAutomaticMode(app, mode) {
+    if (!latestAutomaticScanState || typeof app !== 'string' || !app) {
+      return;
+    }
+    const settings = latestAutomaticScanState.settings.filter((setting) =>
+      setting.app !== app);
+    settings.push({
+      app,
+      mode: mode === 'manual' ? 'manual' : 'automatic',
+    });
+    latestAutomaticScanState = {
+      global_scan_ready: latestAutomaticScanState.global_scan_ready,
+      settings,
+    };
+    leafElements.forEach((entry) => {
+      sendAutomaticScanState(entry.iframe?.contentWindow || null);
+    });
+  }
+
   let activeResize = null;
 
   function beginResize(splitId, pointerEvent) {
@@ -692,6 +756,20 @@
     if (!event || !event.data || typeof event.data !== 'object') {
       return;
     }
+    if (event.data.e === 'vault-automatic-scan-state-request') {
+      if (event.origin === window.location.origin &&
+          isLeafWindow(event.source)) {
+        sendAutomaticScanState(event.source);
+      }
+      return;
+    }
+    if (event.data.e === 'vault-automatic-mode-changed') {
+      if (event.origin === window.location.origin &&
+          isLeafWindow(event.source)) {
+        mergeAutomaticMode(event.data.app, event.data.mode);
+      }
+      return;
+    }
     if (event.data.e === 'layout-state-request') {
       let frameEntry = null;
       let frameId = null;
@@ -855,9 +933,12 @@
       </svg>`;
     const MIN_CHECKING_VISIBLE_MS = 500;
     const COMPLETION_VISIBLE_MS = 4000;
+    const NOTICE_EXIT_MS = 150;
+    const NOTICE_REFLOW_MS = 180;
 
     let eventSource = null;
     const cards = new Map();
+    let desiredCardOrder = [];
 
     function statusText(state) {
       if (state === 'paused') return 'Automatic checks are paused';
@@ -907,20 +988,92 @@
       card.completion = null;
     }
 
+    function reducedMotionRequested() {
+      return typeof window.matchMedia === 'function' &&
+        window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+    }
+
+    function syncTrayVisibility() {
+      tray.hidden = !tray.querySelector('.vault-auto-scan-row');
+    }
+
+    function reorderCards() {
+      const exiting = tray.querySelector('.vault-auto-scan-row.is-exiting');
+      desiredCardOrder.forEach((app) => {
+        const card = cards.get(app);
+        if (!card || !card.item) return;
+        if (!card.item.isConnected || !exiting) {
+          tray.appendChild(card.item);
+        }
+      });
+    }
+
+    function cardPositions() {
+      const positions = new Map();
+      tray.querySelectorAll(
+        '.vault-auto-scan-row:not(.is-exiting)').forEach((item) => {
+        positions.set(item, item.getBoundingClientRect());
+      });
+      return positions;
+    }
+
+    function animateCardReflow(before) {
+      if (reducedMotionRequested()) return;
+      before.forEach((bounds, item) => {
+        if (!item.isConnected || typeof item.animate !== 'function') return;
+        const next = item.getBoundingClientRect();
+        const x = bounds.left - next.left;
+        const y = bounds.top - next.top;
+        if (Math.abs(x) < 0.5 && Math.abs(y) < 0.5) return;
+        item.animate([
+          { transform: `translate3d(${x}px, ${y}px, 0)` },
+          { transform: 'translate3d(0, 0, 0)' }
+        ], {
+          duration: NOTICE_REFLOW_MS,
+          easing: 'cubic-bezier(0.25, 1, 0.5, 1)'
+        });
+      });
+    }
+
+    function finishCardRemoval(card) {
+      const before = cardPositions();
+      card.item.remove();
+      reorderCards();
+      syncTrayVisibility();
+      animateCardReflow(before);
+    }
+
     function removeCard(app) {
       const card = cards.get(app);
-      if (card) {
-        stopCompletion(card);
-        card.item.remove();
-      }
+      if (!card) return;
+      stopCompletion(card);
       cards.delete(app);
-      tray.hidden = cards.size === 0;
+      if (!card.item.isConnected || reducedMotionRequested()) {
+        finishCardRemoval(card);
+        return;
+      }
+      card.item.classList.add('is-exiting');
+      let finished = false;
+      let fallbackTimer = null;
+      const onAnimationEnd = (event) => {
+        if (event.target === card.item &&
+            event.animationName === 'vault-notice-exit') finish();
+      };
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        if (fallbackTimer !== null) window.clearTimeout(fallbackTimer);
+        card.item.removeEventListener('animationend', onAnimationEnd);
+        finishCardRemoval(card);
+      };
+      card.item.addEventListener('animationend', onAnimationEnd);
+      fallbackTimer = window.setTimeout(finish, NOTICE_EXIT_MS + 50);
     }
 
     function resetCards() {
+      desiredCardOrder = [];
       [...cards.keys()].forEach(removeCard);
-      tray.replaceChildren();
-      tray.hidden = true;
+      syncTrayVisibility();
     }
 
     function scheduleCompletion(completion) {
@@ -1033,6 +1186,7 @@
         dismissPending: false,
         pointerInside: false,
         focusInside: false,
+        isNew: true,
         completion: null
       };
       close.addEventListener('click', async () => {
@@ -1229,6 +1383,7 @@
     }
 
     function render(snapshot, options = {}) {
+      broadcastAutomaticScanState(snapshot);
       if (!snapshot || snapshot.global_scan_ready !== true) {
         resetCards();
         return;
@@ -1244,8 +1399,15 @@
           setting && setting.mode === 'manual').map((setting) => setting.app)
         : []);
       const retained = new Set();
+      let enteringCardIndex = 0;
       validRows.forEach((row) => {
-        updateCard(row);
+        const card = updateCard(row);
+        if (card.isNew) {
+          card.item.style.setProperty('--vault-notice-enter-delay',
+            `${Math.min(enteringCardIndex, 2) * 30}ms`);
+          card.isNew = false;
+          enteringCardIndex += 1;
+        }
         retained.add(row.app);
       });
       const completion = snapshot.completion;
@@ -1260,19 +1422,21 @@
       cards.forEach((card, app) => {
         if (card.completion && !manualApps.has(app)) retained.add(app);
       });
-      [...cards.keys()].forEach((app) => {
-        if (!retained.has(app)) removeCard(app);
-      });
+      const order = [];
       validRows.forEach((row) => {
-        const card = cards.get(row.app);
-        if (card) tray.appendChild(card.item);
+        if (!order.includes(row.app)) order.push(row.app);
       });
       cards.forEach((card, app) => {
-        if (card.completion && !liveApps.has(app)) {
-          tray.appendChild(card.item);
+        if (card.completion && !liveApps.has(app) && !order.includes(app)) {
+          order.push(app);
         }
       });
-      tray.hidden = cards.size === 0;
+      desiredCardOrder = order;
+      [...cards.keys()].forEach((app) => {
+        if (!retained.has(app)) removeCard(app);
+      });
+      reorderCards();
+      syncTrayVisibility();
     }
 
     async function loadState() {
@@ -1308,7 +1472,6 @@
         }
       };
       eventSource.onerror = () => {
-        resetCards();
         loadState();
       };
     }

package/server/public/vault.css

@@ -910,6 +910,39 @@ body[data-vault-mode="global"] .vault-explorer {
   display: grid;
   gap: 0;
 }
+.vault-find-size-setting {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 16px;
+  min-height: 68px;
+  padding: 12px 18px;
+  border-bottom: 1px solid var(--task-border);
+  background: var(--task-panel);
+}
+.vault-find-size-copy {
+  display: grid;
+  min-width: 0;
+  gap: 3px;
+  color: var(--task-text);
+  cursor: pointer;
+}
+.vault-find-size-copy strong {
+  font-size: 12.5px;
+  font-weight: 650;
+  line-height: 1.2;
+}
+.vault-find-size-copy span {
+  color: var(--task-muted);
+  font-size: 10.5px;
+  font-weight: 450;
+  line-height: 1.2;
+}
+.vault-select.vault-find-size-select {
+  min-width: 118px;
+  height: 34px;
+  cursor: pointer;
+}
 .vault-find-choice {
   display: grid;
   width: 100%;
@@ -2037,6 +2070,11 @@ body.dark .vault-row-action .vault-text-button:hover:not(:disabled) {
 }
 @media (max-width: 520px) {
   .vault-storage-legend { column-gap: 14px; row-gap: 4px; }
+  .vault-find-size-setting {
+    grid-template-columns: minmax(0, 1fr);
+    gap: 10px;
+  }
+  .vault-select.vault-find-size-select { width: 100%; }
 }
 @media (pointer: coarse) {
   .vault-page {
@@ -2048,6 +2086,7 @@ body.dark .vault-row-action .vault-text-button:hover:not(:disabled) {
   .vault-result .vault-button,
   .vault-group-action .vault-button { min-height: 44px; }
   .vault-scan-size-option { min-height: 44px; }
+  .vault-select.vault-find-size-select { height: 44px; }
   .vault-icon-button { width: 44px; height: 44px; }
   .vault-find-tree-row {
     grid-template-columns: 44px 44px 17px minmax(0, 1fr);