pinokiod 8.0.57 → 8.0.58

package/kernel/vault/automatic_scans.js

@@ -152,8 +152,9 @@ class AutomaticScans {
     return setting && setting.mode === "manual" ? "manual" : "automatic"
   }
 
-  broadcast() {
+  broadcast(completion = null) {
     const snapshot = this.snapshot()
+    if (completion) snapshot.completion = completion
     for (const listener of this.listeners) {
       try {
         listener(snapshot)
@@ -617,6 +618,7 @@ class AutomaticScans {
 
   async precheckFinished(active, result, error) {
     const app = active.app
+    let completion = null
     try {
       await this.withAppTransition(app, async () => {
         let reason = active.reason
@@ -661,13 +663,20 @@ class AutomaticScans {
           ? Object.assign({}, this.settings.get(app))
           : null
         try {
-          await this.publishResultNow(app, result)
+          const outcome = await this.publishResultNow(app, result)
+          if (outcome === "empty") {
+            completion = {
+              app,
+              outcome: "no_possible_duplicates"
+            }
+          }
         } catch (publicationError) {
           this.restorePrevious(app)
           throw publicationError
         }
         reason = active.reason
         if (reason) {
+          completion = null
           await this.restorePublishedState(app, entry, previousSetting)
           this.entries.set(app, entry)
           this.log("publication-reverted", { app, reason })
@@ -682,7 +691,7 @@ class AutomaticScans {
       })
     } finally {
       if (this.active === active) this.active = null
-      this.broadcast()
+      this.broadcast(completion)
       this.schedule()
     }
   }
@@ -764,7 +773,7 @@ class AutomaticScans {
         possible_files: possibleFiles,
         acknowledged: acknowledged === result.signature
       })
-      return
+      return "result"
     }
     const acknowledged = (this.settings.get(app) || {})
       .acknowledged_signature
@@ -777,6 +786,7 @@ class AutomaticScans {
     }
     this.entries.delete(app)
     this.log("no-possible-matches", { app })
+    return "empty"
   }
 
   async clearAutomaticState(apps, reason, options = {}) {

package/package.json

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

package/server/public/layout.js

@@ -866,8 +866,16 @@
         <circle cx="10" cy="10" r="7.5"></circle>
         <path d="M8 7.25v5.5M12 7.25v5.5"></path>
       </svg>`;
+    const COMPLETE_ICON = `
+      <svg viewBox="0 0 20 20" aria-hidden="true">
+        <circle cx="10" cy="10" r="7.5"></circle>
+        <path d="m6.75 10.1 2.1 2.1 4.6-4.65"></path>
+      </svg>`;
+    const COMPLETION_VISIBLE_MS = 4000;
 
     let eventSource = null;
+    let visibleCheckingApps = new Set();
+    const completions = new Map();
 
     function statusText(row) {
       if (row.state === 'paused') {
@@ -912,6 +920,97 @@
       tray.hidden = tray.childElementCount === 0;
     }
 
+    function removeCompletion(app) {
+      const completion = completions.get(app);
+      if (!completion) return;
+      if (completion.timer) window.clearTimeout(completion.timer);
+      completions.delete(app);
+      removeRow(completion.item);
+    }
+
+    function clearCompletions() {
+      [...completions.keys()].forEach(removeCompletion);
+    }
+
+    function scheduleCompletion(completion) {
+      if (completion.paused.size || completion.timer) return;
+      completion.startedAt = Date.now();
+      completion.timer = window.setTimeout(() => {
+        completion.timer = null;
+        removeCompletion(completion.app);
+      }, completion.remaining);
+    }
+
+    function setCompletionPaused(completion, reason, paused) {
+      if (paused) {
+        if (completion.paused.has(reason)) return;
+        if (!completion.paused.size && completion.timer) {
+          completion.remaining = Math.max(0,
+            completion.remaining - (Date.now() - completion.startedAt));
+          window.clearTimeout(completion.timer);
+          completion.timer = null;
+        }
+        completion.paused.add(reason);
+        return;
+      }
+      completion.paused.delete(reason);
+      if (!completion.paused.size) scheduleCompletion(completion);
+    }
+
+    function startCompletion(app) {
+      if (completions.has(app)) return;
+      const item = document.createElement('div');
+      item.className = 'vault-auto-scan-row';
+      item.dataset.state = 'complete';
+
+      const close = document.createElement('button');
+      close.type = 'button';
+      close.className = 'vault-auto-scan-close';
+      close.setAttribute('aria-label',
+        `Dismiss Disk Saver completion for ${app}`);
+      close.title = 'Dismiss';
+      close.textContent = '×';
+
+      const icon = document.createElement('span');
+      icon.className = 'vault-auto-scan-icon';
+      icon.innerHTML = COMPLETE_ICON;
+
+      const copy = document.createElement('span');
+      copy.className = 'vault-auto-scan-copy';
+      const appName = document.createElement('span');
+      appName.className = 'vault-auto-scan-app';
+      appName.textContent = app;
+      appName.title = app;
+      const status = document.createElement('span');
+      status.className = 'vault-auto-scan-status';
+      status.textContent = 'No possible duplicate files found';
+      copy.append(appName, status);
+      item.append(close, icon, copy);
+
+      const completion = {
+        app,
+        item,
+        timer: null,
+        remaining: COMPLETION_VISIBLE_MS,
+        startedAt: 0,
+        paused: new Set()
+      };
+      close.addEventListener('click', () => removeCompletion(app));
+      item.addEventListener('mouseenter', () =>
+        setCompletionPaused(completion, 'pointer', true));
+      item.addEventListener('mouseleave', () =>
+        setCompletionPaused(completion, 'pointer', false));
+      item.addEventListener('focusin', () =>
+        setCompletionPaused(completion, 'focus', true));
+      item.addEventListener('focusout', (event) => {
+        if (!item.contains(event.relatedTarget)) {
+          setCompletionPaused(completion, 'focus', false);
+        }
+      });
+      completions.set(app, completion);
+      scheduleCompletion(completion);
+    }
+
     function automaticSettingsKey(app) {
       return `pinokio:vault:auto-settings:${encodeURIComponent(app)}`;
     }
@@ -968,15 +1067,34 @@
       return opened;
     }
 
-    function render(snapshot) {
+    function render(snapshot, options = {}) {
       const rows = snapshot && Array.isArray(snapshot.rows)
         ? snapshot.rows
         : [];
+      const validRows = rows.filter((row) =>
+        row && typeof row.app === 'string' && row.app);
+      const liveApps = new Set(validRows.map((row) => row.app));
+      [...completions.keys()].forEach((app) => {
+        if (liveApps.has(app)) removeCompletion(app);
+      });
+      const manualApps = new Set(snapshot && Array.isArray(snapshot.settings)
+        ? snapshot.settings.filter((setting) =>
+          setting && setting.mode === 'manual').map((setting) => setting.app)
+        : []);
+      manualApps.forEach(removeCompletion);
+
+      const completion = snapshot && snapshot.completion;
+      if (options.acceptCompletion && completion &&
+          completion.outcome === 'no_possible_duplicates' &&
+          typeof completion.app === 'string' && completion.app &&
+          visibleCheckingApps.has(completion.app) &&
+          !liveApps.has(completion.app) &&
+          !manualApps.has(completion.app)) {
+        startCompletion(completion.app);
+      }
+
       const fragment = document.createDocumentFragment();
-      rows.forEach((row) => {
-        if (!row || typeof row.app !== 'string' || !row.app) {
-          return;
-        }
+      validRows.forEach((row) => {
         const item = document.createElement('div');
         item.className = 'vault-auto-scan-row';
         item.dataset.state = row.state || 'checking';
@@ -988,6 +1106,7 @@
         close.title = 'Dismiss';
         close.textContent = '×';
         close.addEventListener('click', async () => {
+          if (row.state === 'checking') visibleCheckingApps.delete(row.app);
           close.disabled = true;
           try {
             const result = await requestAction(
@@ -1000,6 +1119,9 @@
             removeRow(item);
           } catch (error) {
             console.warn('[Disk Saver] Automatic check dismissal failed', error);
+            if (row.state === 'checking' && item.isConnected) {
+              visibleCheckingApps.add(row.app);
+            }
             close.disabled = false;
           }
         });
@@ -1088,8 +1210,16 @@
         item.append(close, icon, copy, controls);
         fragment.appendChild(item);
       });
+      completions.forEach((completionRow) => {
+        if (!liveApps.has(completionRow.app)) {
+          fragment.appendChild(completionRow.item);
+        }
+      });
       tray.replaceChildren(fragment);
       tray.hidden = tray.childElementCount === 0;
+      visibleCheckingApps = new Set(validRows
+        .filter((row) => row.state === 'checking')
+        .map((row) => row.app));
     }
 
     async function loadState() {
@@ -1119,12 +1249,13 @@
         '/info/vault/automatic-scans/events');
       eventSource.onmessage = (event) => {
         try {
-          render(JSON.parse(event.data));
+          render(JSON.parse(event.data), { acceptCompletion: true });
         } catch (error) {
           console.debug('[Disk Saver] Invalid automatic check state', error);
         }
       };
       eventSource.onerror = () => {
+        clearCompletions();
         loadState();
       };
     }

package/server/views/layout.ejs

@@ -333,7 +333,8 @@
       opacity: 0.55;
     }
 
-    .vault-auto-scan-row[data-state="result"] {
+    .vault-auto-scan-row[data-state="result"],
+    .vault-auto-scan-row[data-state="complete"] {
       grid-template-rows: 16px 30px;
       min-height: 66px;
       padding-top: 10px;
@@ -342,14 +343,25 @@
 
     .vault-auto-scan-row[data-state="result"] .vault-auto-scan-icon,
     .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy,
-    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-controls {
+    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-controls,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-icon,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
       grid-row: 1 / 3;
     }
 
-    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy {
+    .vault-auto-scan-row[data-state="result"] .vault-auto-scan-copy,
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
       grid-template-rows: 16px 30px;
     }
 
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-copy {
+      grid-column: 2 / 4;
+    }
+
+    .vault-auto-scan-row[data-state="complete"] .vault-auto-scan-icon {
+      color: var(--vault-notice-accent);
+    }
+
     @keyframes vault-notice-enter {
       from { opacity: 0; transform: translateY(6px); }
       to { opacity: 1; transform: translateY(0); }

package/test/vault-automatic-scan-ui.test.js

@@ -227,6 +227,234 @@ test("checking notices expose settings, Pause, and dismissal", async () => {
   dom.window.close()
 })
 
+test("an empty automatic check briefly confirms completion", async () => {
+  const template = await fs.promises.readFile(
+    path.join(root, "server", "views", "layout.ejs"), "utf8")
+  const script = await fs.promises.readFile(
+    path.join(root, "server", "public", "layout.js"), "utf8")
+  const html = ejs.render(template, {
+    theme: "light",
+    agent: "web",
+    initialPath: "/v/ComfyUI",
+    defaultPath: "/home",
+    sessionId: null,
+    vaultEnabled: true
+  })
+  const dom = new JSDOM(html, {
+    runScripts: "outside-only",
+    pretendToBeVisual: true,
+    url: "http://localhost/"
+  })
+  const eventSources = []
+  const requests = []
+  const completionTimers = []
+  const nativeSetTimeout = dom.window.setTimeout.bind(dom.window)
+  const nativeClearTimeout = dom.window.clearTimeout.bind(dom.window)
+  dom.window.setTimeout = (callback, delay, ...args) => {
+    if (delay <= 4000 && delay > 3500) {
+      const timer = {
+        callback,
+        delay,
+        cleared: false,
+        id: 10000 + completionTimers.length
+      }
+      completionTimers.push(timer)
+      return timer.id
+    }
+    return nativeSetTimeout(callback, delay, ...args)
+  }
+  dom.window.clearTimeout = (id) => {
+    const timer = completionTimers.find((candidate) => candidate.id === id)
+    if (timer) {
+      timer.cleared = true
+      return
+    }
+    nativeClearTimeout(id)
+  }
+  dom.window.EventSource = class EventSource {
+    constructor(url) {
+      this.url = url
+      eventSources.push(this)
+    }
+    close() {}
+  }
+  dom.window.fetch = async (url, options = {}) => {
+    requests.push({ url, options })
+    if (url === "/info/vault/automatic-scans") {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          enabled: true,
+          rows: [],
+          settings: [{ app: "ComfyUI", mode: "automatic" }]
+        })
+      }
+    }
+    if (url === "/vault/action") {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ dismissed: true, app: "ComfyUI" })
+      }
+    }
+    throw new Error(`Unexpected request: ${url}`)
+  }
+
+  dom.window.eval(script)
+  await waitFor(() => eventSources.length === 1)
+  const send = (payload) => eventSources[0].onmessage({
+    data: JSON.stringify(payload)
+  })
+
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  const tray = dom.window.document.getElementById("vault-auto-scan-tray")
+  assert.equal(tray.hidden, true,
+    "a completion event cannot appear without a visible checking row")
+
+  send({
+    enabled: true,
+    rows: [
+      {
+        app: "ComfyUI",
+        state: "checking",
+        notice_id: "checking:1:"
+      },
+      {
+        app: "OtherApp",
+        state: "paused",
+        notice_id: "paused:1:"
+      }
+    ],
+    settings: [
+      { app: "ComfyUI", mode: "automatic" },
+      { app: "OtherApp", mode: "manual" }
+    ]
+  })
+  send({
+    enabled: true,
+    rows: [{
+      app: "OtherApp",
+      state: "paused",
+      notice_id: "paused:1:"
+    }],
+    settings: [
+      { app: "ComfyUI", mode: "automatic" },
+      { app: "OtherApp", mode: "manual" }
+    ],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+
+  const completed = tray.querySelector(
+    '.vault-auto-scan-row[data-state="complete"]')
+  assert.ok(completed)
+  assert.equal(completed.querySelector(
+    ".vault-auto-scan-app").textContent, "ComfyUI")
+  assert.equal(completed.querySelector(
+    ".vault-auto-scan-status").textContent,
+  "No possible duplicate files found")
+  assert.ok(completed.querySelector(".vault-auto-scan-icon svg"))
+  assert.equal(completed.querySelector(".vault-auto-scan-settings"), null)
+  assert.equal(completed.querySelector(".vault-auto-scan-action"), null)
+  assert.equal(completionTimers[0].delay, 4000)
+
+  tray.querySelector(
+    '.vault-auto-scan-row[data-state="paused"] .vault-auto-scan-action').click()
+  await waitFor(() => requests.some((request) =>
+    request.url === "/info/vault/automatic-scans"))
+  await new Promise((resolve) => nativeSetTimeout(resolve, 0))
+  assert.equal(completed.isConnected, true,
+    "refreshing durable tray state preserves an active completion")
+  assert.equal(completionTimers.length, 1,
+    "a durable state refresh does not restart the completion timer")
+
+  completed.dispatchEvent(new dom.window.MouseEvent("mouseenter"))
+  assert.equal(completionTimers[0].cleared, true)
+  completed.dispatchEvent(new dom.window.MouseEvent("mouseleave"))
+  assert.equal(completionTimers.length, 2)
+  assert.ok(completionTimers[1].delay <= 4000)
+
+  const closeButton = completed.querySelector(".vault-auto-scan-close")
+  closeButton.dispatchEvent(new dom.window.FocusEvent("focusin", {
+    bubbles: true
+  }))
+  assert.equal(completionTimers[1].cleared, true)
+  closeButton.dispatchEvent(new dom.window.FocusEvent("focusout", {
+    bubbles: true,
+    relatedTarget: null
+  }))
+  assert.equal(completionTimers.length, 3)
+  completionTimers[2].callback()
+  assert.equal(tray.hidden, true)
+
+  send({
+    enabled: true,
+    rows: [{
+      app: "ComfyUI",
+      state: "checking",
+      notice_id: "checking:2:"
+    }],
+    settings: [{ app: "ComfyUI", mode: "automatic" }]
+  })
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  assert.equal(tray.hidden, false)
+  eventSources[0].onerror()
+  await new Promise((resolve) => nativeSetTimeout(resolve, 0))
+  assert.equal(tray.hidden, true,
+    "a reconnect drops presentation-only completion state")
+
+  send({
+    enabled: true,
+    rows: [{
+      app: "ComfyUI",
+      state: "checking",
+      notice_id: "checking:3:"
+    }],
+    settings: [{ app: "ComfyUI", mode: "automatic" }]
+  })
+  tray.querySelector(".vault-auto-scan-close").click()
+  send({
+    enabled: true,
+    rows: [],
+    settings: [{ app: "ComfyUI", mode: "automatic" }],
+    completion: {
+      app: "ComfyUI",
+      outcome: "no_possible_duplicates"
+    }
+  })
+  await waitFor(() => tray.hidden)
+  assert.equal(tray.querySelector(
+    '.vault-auto-scan-row[data-state="complete"]'), null,
+  "a closed checking row cannot be replaced by completion")
+  assert.ok(requests.some((request) => {
+    if (request.url !== "/vault/action" || !request.options.body) return false
+    const payload = JSON.parse(request.options.body)
+    return payload.action === "automatic_dismiss" &&
+      payload.notice_id === "checking:3:"
+  }))
+
+  dom.window.close()
+})
+
 test("the shared layout does not initialize automatic notices when Vault is disabled", async () => {
   const template = await fs.promises.readFile(
     path.join(root, "server", "views", "layout.ejs"), "utf8")

package/test/vault-automatic-scans.test.js

@@ -409,12 +409,29 @@ describe("automatic app checks", () => {
       await handle.close()
     }
     const vault = await makeVault(home)
+    const broadcasts = []
+    const unsubscribe = vault.automaticScans.subscribe((snapshot) => {
+      broadcasts.push(snapshot)
+    })
 
     vault.automaticScans.queueApp("threshold-app")
     await waitFor(() => !vault.automaticScans.active &&
       !vault.automaticScans.entries.has("threshold-app"))
 
     assert.deepEqual(vault.automaticScans.snapshot().rows, [])
+    assert.deepEqual(broadcasts.find((snapshot) => snapshot.completion)
+      ?.completion, {
+      app: "threshold-app",
+      outcome: "no_possible_duplicates"
+    })
+    assert.equal("completion" in vault.automaticScans.snapshot(), false)
+    let restoredSnapshot = null
+    const unsubscribeRestored = vault.automaticScans.subscribe((snapshot) => {
+      restoredSnapshot = snapshot
+    })
+    assert.equal("completion" in restoredSnapshot, false)
+    unsubscribeRestored()
+    unsubscribe()
     assert.equal(await vault.registry.scanFor("app:threshold-app"), null)
     await close(vault)
   })