pinokiod 8.0.78 → 8.0.80

package/test/tab-notification-settings.test.js

@@ -0,0 +1,135 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const { JSDOM, VirtualConsole } = require("jsdom")
+
+const root = path.resolve(__dirname, "..")
+const notifierPath = path.resolve(root, "server/public/tab-idle-notifier.js")
+const popoverPath = path.resolve(root, "server/public/tab-link-popover.js")
+const popoverCssPath = path.resolve(root, "server/public/tab-link-popover.css")
+
+const settle = () => new Promise((resolve) => setImmediate(resolve))
+
+test("desktop notification settings mount inline and persist both scopes", async () => {
+  const script = await fs.readFile(notifierPath, "utf8")
+  const virtualConsole = new VirtualConsole()
+  const dom = new JSDOM(`<!doctype html><html><head></head><body>
+    <div class="appcanvas vertical">
+      <aside>
+        <div class="menu-container">
+          <a class="frame-link" href="/run/test" target="test-shell" data-can-notify="true">
+            <span class="tab"><span class="tab-main">Test</span></span>
+          </a>
+        </div>
+      </aside>
+    </div>
+    <div id="settings"></div>
+  </body></html>`, {
+    url: "http://127.0.0.1:42000/run/test",
+    runScripts: "outside-only",
+    pretendToBeVisual: true,
+    virtualConsole,
+    beforeParse(window) {
+      window.fetch = async () => ({
+        ok: true,
+        async json() {
+          return {
+            sounds: [{
+              url: "/sound/bell.mp3",
+              label: "Bell",
+              filename: "bell.mp3"
+            }]
+          }
+        }
+      })
+      window.Audio = class {
+        play() {
+          return Promise.resolve()
+        }
+      }
+    }
+  })
+
+  try {
+    dom.window.eval(script)
+    const link = dom.window.document.querySelector(".frame-link")
+    const settings = dom.window.document.getElementById("settings")
+    let enabledChange = null
+    let soundChange = null
+
+    const mounted = dom.window.PinokioIdleNotifier.mountSettingsForLink(link, settings, {
+      onEnabledChange(enabled) {
+        enabledChange = enabled
+      },
+      onSoundChange(choice) {
+        soundChange = choice
+      }
+    })
+
+    assert.equal(mounted, true)
+    assert.equal(settings.textContent.includes("Notifications for this tab"), true)
+    assert.equal(settings.textContent.includes("Sound"), true)
+
+    const toggle = settings.querySelector('[role="switch"]')
+    const status = settings.querySelector(".tab-link-notification-toggle-status")
+    const select = settings.querySelector("select")
+    assert.equal(toggle.getAttribute("aria-checked"), "true")
+    assert.equal(status.textContent, "On")
+    assert.equal(select.value, "__default__")
+
+    toggle.click()
+    assert.equal(toggle.getAttribute("aria-checked"), "false")
+    assert.equal(status.textContent, "Off")
+    assert.equal(enabledChange, false)
+    assert.deepEqual(JSON.parse(dom.window.localStorage.getItem("pinokio:idle-prefs")), {
+      "test-shell": false
+    })
+
+    toggle.click()
+    assert.equal(toggle.getAttribute("aria-checked"), "true")
+    assert.equal(status.textContent, "On")
+    assert.equal(enabledChange, true)
+    assert.equal(dom.window.localStorage.getItem("pinokio:idle-prefs"), null)
+
+    await settle()
+    assert.equal(Array.from(select.options).some((option) => option.textContent === "Bell"), true)
+    select.value = "/sound/bell.mp3"
+    select.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    assert.equal(soundChange, "/sound/bell.mp3")
+    assert.deepEqual(JSON.parse(dom.window.localStorage.getItem("pinokio:idle-sound")), {
+      choice: "/sound/bell.mp3"
+    })
+  } finally {
+    dom.window.close()
+  }
+})
+
+test("tab actions expands notification settings instead of reopening at the sidebar", async () => {
+  const [popover, css] = await Promise.all([
+    fs.readFile(popoverPath, "utf8"),
+    fs.readFile(popoverCssPath, "utf8")
+  ])
+  const branchStart = popover.indexOf('if (action === "notifications")')
+  const branchEnd = popover.indexOf('const url = item.getAttribute("data-url")', branchStart)
+  assert.notEqual(branchStart, -1)
+  assert.notEqual(branchEnd, -1)
+  const branch = popover.slice(branchStart, branchEnd)
+
+  assert.match(branch, /mountSettingsForLink\(activeLink, panel/)
+  assert.match(branch, /tab-link-notification-settings/)
+  assert.match(branch, /panel\.setAttribute\("role", "group"\)/)
+  assert.doesNotMatch(branch, /hideTabLinkPopover/)
+  assert.doesNotMatch(branch, /openMenuForLink/)
+  assert.match(css, /\.tab-link-notification-settings\s*\{/)
+  assert.match(css, /\.tab-link-notification-switch:focus-visible/)
+})
+
+test("legacy notification popover stays inside the viewport", async () => {
+  const notifier = await fs.readFile(notifierPath, "utf8")
+
+  assert.match(notifier, /\.pinokio-notify-popover \{[\s\S]*position: fixed;/)
+  assert.match(notifier, /\.pinokio-notify-popover \{[\s\S]*max-height: calc\(100dvh - 24px\);/)
+  assert.match(notifier, /const topAbove = rect\.top - menuHeight - menuGap;/)
+  assert.match(notifier, /top \+ menuHeight > window\.innerHeight - viewportPadding/)
+})

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

@@ -1247,6 +1247,7 @@ describe("automatic app checks", () => {
     await fs.promises.writeFile(second, "same-content")
     const vault = await makeVault(home)
     vault.lastScanCache.set("", { candidate_min_bytes: 1 })
+    await vault.registry.setScanSetting(`app:${app}`, 0)
     const hashedPaths = []
     const originalHashFile = vault.hashFile.bind(vault)
     vault.hashFile = async (filePath, options) => {

package/test/vault-engine.test.js

@@ -29,13 +29,18 @@ const makeOutside = async () => {
   return directory
 }
 
-const makeVault = async () => {
+const makeVault = async ({ candidateSize = CANDIDATE_SIZE_OPTIONS[0] } = {}) => {
   const home = await makeHome()
   const kernel = { homedir: home, platform: process.platform }
   const vault = new Vault(kernel)
   kernel.vault = vault
   await vault.init()
   vault.sizeThreshold = CANDIDATE_SIZE_OPTIONS[0]
+  if (candidateSize !== null) {
+    await vault.perform("set_candidate_size", {
+      candidate_size: candidateSize
+    })
+  }
   return { home, kernel, vault }
 }
 
@@ -175,15 +180,142 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
-  test("the published global scan minimum is reused by automatic checks", async () => {
-    const { vault } = await makeVault()
+  test("global and app minimum sizes persist and drive their own scans", async () => {
+    const { home, vault } = await makeVault()
+    const app = "minimum-size-app"
+    const appRoot = path.join(home, "api", app)
+    const appScope = `app:${app}`
+    const globalMinimum = CANDIDATE_SIZE_OPTIONS[2]
+    const appMinimum = CANDIDATE_SIZE_OPTIONS[1]
+    await fs.promises.mkdir(appRoot)
+    await vault.openWorkspace()
+
+    assert.equal((await vault.perform("set_candidate_size", {
+      candidate_size: globalMinimum
+    })).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.perform("set_candidate_size", {
+      scope_id: appScope,
+      candidate_size: appMinimum
+    })).candidate_min_bytes, appMinimum)
+    assert.equal((await vault.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.status(appScope)).candidate_min_bytes, appMinimum)
+
+    const starts = []
+    vault.globalScanReady = async () => true
+    vault.startScan = (scopeId, threshold) => {
+      starts.push({ scope_id: scopeId, threshold })
+      return { started: true }
+    }
+    assert.deepEqual(await vault.perform("scan", {
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.deepEqual(await vault.perform("scan", {
+      scope_id: appScope,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.deepEqual(starts, [
+      { scope_id: null, threshold: globalMinimum },
+      { scope_id: appScope, threshold: appMinimum }
+    ])
+    let folderThreshold = null
+    vault.startFolderDiscovery = (folderPath, threshold) => {
+      folderThreshold = threshold
+      return { started: true }
+    }
+    assert.deepEqual(await vault.perform("find_folders", {
+      path: home,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[0]
+    }), { started: true })
+    assert.equal(folderThreshold, globalMinimum)
+    assert.equal((await vault.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await vault.status(appScope)).candidate_min_bytes, appMinimum)
+    assert.equal((await vault.automaticScans.candidatePolicy(app)).threshold,
+      appMinimum)
+
+    await close(vault)
+    const reopened = new Vault({ homedir: home, platform: process.platform })
+    await reopened.init()
+    assert.equal((await reopened.status()).candidate_min_bytes, globalMinimum)
+    assert.equal((await reopened.status(appScope)).candidate_min_bytes,
+      appMinimum)
+    await close(reopened)
+  })
+
+  test("reading a default minimum size does not persist it", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    assert.equal(await vault.registry.scanSetting(), null)
+    assert.equal((await vault.status()).candidate_min_bytes, SIZE_THRESHOLD)
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("minimum size settings reject coerced values", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    for (const candidateSize of [
+      null,
+      "",
+      String(CANDIDATE_SIZE_OPTIONS[1])
+    ]) {
+      assert.match((await vault.perform("set_candidate_size", {
+        candidate_size: candidateSize
+      })).error, /valid minimum file size/i)
+    }
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("minimum size settings reject malformed scopes", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
+
+    const result = await vault.perform("set_candidate_size", {
+      scope_id: 123,
+      candidate_size: CANDIDATE_SIZE_OPTIONS[1]
+    })
+
+    assert.match(result.error, /valid scan scope/i)
+    assert.equal(await vault.registry.scanSetting(), null)
+
+    await close(vault)
+  })
+
+  test("scan history does not become a minimum size setting", async () => {
+    const home = await makeHome()
+    const vault = new Vault({ homedir: home, platform: process.platform })
+    await vault.init()
+    await vault.perform("set_candidate_size", {
+      candidate_size: CANDIDATE_SIZE_OPTIONS[2]
+    })
+    assert.equal((await vault.perform("scan")).started, true)
+    await waitForEngine(() => !vault.scanPromise &&
+      !vault.scanCompletionPromise)
+    await close(vault)
+
+    const database = new Database(path.join(home, "vault", "registry.sqlite3"))
+    database.exec("DROP TABLE minimum_size_settings")
+    database.close()
+
+    const reopened = new Vault({ homedir: home, platform: process.platform })
+    await reopened.init()
+    assert.equal((await reopened.status()).candidate_min_bytes,
+      SIZE_THRESHOLD)
+    assert.equal(await reopened.registry.scanSetting(), null)
+    await close(reopened)
+  })
+
+  test("the saved global minimum is reused by unscoped policy reads", async () => {
+    const { vault } = await makeVault({ candidateSize: null })
     const selected = CANDIDATE_SIZE_OPTIONS[2]
 
     assert.equal((await vault.status()).global_candidate_min_bytes,
       SIZE_THRESHOLD)
-    assert.deepEqual(await vault.perform("scan", {
+    await vault.perform("set_candidate_size", {
       candidate_size: selected
-    }), { started: true })
+    })
+    assert.deepEqual(await vault.perform("scan"), { started: true })
     await waitForEngine(() => !vault.scanPromise &&
       !vault.scanCompletionPromise)
 
@@ -994,6 +1126,9 @@ describe("Save Space engine", () => {
       crypto.randomBytes(512))
     vault.sizeThreshold = 0
     await vault.sweeper.scan()
+    await vault.perform("set_candidate_size", {
+      candidate_size: selectedThreshold
+    })
 
     const stageDiscoveryFiles = vault.registry.stageFolderDiscoveryFiles
       .bind(vault.registry)
@@ -1039,18 +1174,22 @@ describe("Save Space engine", () => {
     await close(vault)
   })
 
-  test("Find folders requires an explicit supported threshold", async () => {
+  test("Find folders ignores request thresholds and uses the saved setting", async () => {
     const { vault } = await makeVault()
     const outside = await makeOutside()
+    const thresholds = []
+    vault.startFolderDiscovery = (folderPath, threshold) => {
+      thresholds.push(threshold)
+      return { started: true }
+    }
 
-    assert.match((await vault.perform("find_folders", {
-      path: outside
-    })).error, /valid minimum file size/i)
-    assert.match((await vault.perform("find_folders", {
+    assert.deepEqual(await vault.perform("find_folders", {
       path: outside,
       candidate_size: 123
-    })).error, /valid minimum file size/i)
-    assert.equal(vault.folderDiscoveryPromise, null)
+    }), { started: true })
+    assert.deepEqual(thresholds, [CANDIDATE_SIZE_OPTIONS[0]])
+    assert.equal((await vault.status()).candidate_min_bytes,
+      CANDIDATE_SIZE_OPTIONS[0])
     await close(vault)
   })
 

package/test/vault-ui.test.js

@@ -414,7 +414,7 @@ const makePage = async (status, options = {}) => {
     const childManifest = parent
       ? folderDiscoveryChildren[parent]
       : null
-    const response = parent
+    const response = await (parent
       ? typeof childManifest === "function"
         ? childManifest(childPage)
         : childManifest || {
@@ -425,7 +425,7 @@ const makePage = async (status, options = {}) => {
             page_size: 500,
             pages: 1
           }
-      : typeof status === "function" ? status(url) : status
+      : typeof status === "function" ? status(url) : status)
     if (options.deferAutomaticStatus &&
         url === "/info/vault/automatic-scans") {
       await deferredAutomaticStatus
@@ -778,7 +778,7 @@ describe("Save Space interface", () => {
       request.action === "scan"))
     const scan = requests.find((request) => request.action === "scan")
     assert.equal(scan.scope_id, null)
-    assert.equal(scan.candidate_size, 100 * candidateBase ** 2)
+    assert.equal("candidate_size" in scan, false)
     await settle()
     dom.window.close()
   })
@@ -866,12 +866,13 @@ describe("Save Space interface", () => {
     dom.window.close()
   })
 
-  test("the scan minimum follows the latest global scan, not browser storage", async () => {
+  test("a scan relies on the saved scope setting, not browser storage", async () => {
     const candidateBase = process.platform === "win32" ? 1024 : 1000
-    const published = 50 * candidateBase ** 2
+    const saved = 50 * candidateBase ** 2
     const stored = 10 * candidateBase ** 2
     const { dom, requests } = await makePage(fixture([], {
-      global_candidate_min_bytes: published
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: 100 * candidateBase ** 2
     }), {
       storedCandidateSize: stored
     })
@@ -882,13 +883,39 @@ describe("Save Space interface", () => {
     document.getElementById("btn-scan").click()
     await waitFor(() => requests.some((request) =>
       request.action === "scan"))
-    assert.equal(requests.find((request) =>
-      request.action === "scan").candidate_size, published)
+    assert.equal("candidate_size" in requests.find((request) =>
+      request.action === "scan"), false)
 
     await settle()
     dom.window.close()
   })
 
+  test("an app displays and immediately saves its own minimum size", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const appMinimum = candidateBase ** 2
+    const globalMinimum = 10 * candidateBase ** 2
+    const selected = 50 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([], {
+      candidate_min_bytes: appMinimum,
+      global_candidate_min_bytes: globalMinimum
+    }), { appMode: true })
+    const document = dom.window.document
+    const selector = document.getElementById("vault-candidate-size")
+
+    assert.equal(selector.value, String(appMinimum))
+    selector.value = String(selected)
+    selector.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    await waitFor(() => requests.some((request) =>
+      request.action === "set_candidate_size"))
+    const request = requests.find((entry) =>
+      entry.action === "set_candidate_size")
+    assert.equal(request.scope_id, "app:app")
+    assert.equal(request.candidate_size, selected)
+    assert.equal(selector.value, String(selected))
+
+    dom.window.close()
+  })
+
   test("a threshold chosen before initial status remains selected", async () => {
     const candidateBase = process.platform === "win32" ? 1024 : 1000
     const published = 50 * candidateBase ** 2
@@ -914,13 +941,87 @@ describe("Save Space interface", () => {
     document.getElementById("btn-scan").click()
     await waitFor(() => requests.some((request) =>
       request.action === "scan"))
-    assert.equal(requests.find((request) =>
-      request.action === "scan").candidate_size, selected)
+    const savedIndex = requests.findIndex((request) =>
+      request.action === "set_candidate_size")
+    const scanIndex = requests.findIndex((request) =>
+      request.action === "scan")
+    assert.ok(savedIndex >= 0 && savedIndex < scanIndex)
+    assert.equal("candidate_size" in requests[scanIndex], false)
 
     await settle()
     dom.window.close()
   })
 
+  test("a rejected minimum size save blocks a pending scan and restores the saved size", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const saved = 50 * candidateBase ** 2
+    const selected = 10 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([], {
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: saved
+    }), {
+      actionResults: {
+        set_candidate_size: { error: "Could not save minimum file size." }
+      }
+    })
+    const document = dom.window.document
+
+    document.querySelector(`[data-candidate-size="${selected}"]`).click()
+    document.getElementById("btn-scan").click()
+
+    await waitFor(() => /50 MB\+/.test(document.getElementById(
+      "vault-scan-size-label").textContent) &&
+      /could not save minimum file size/i.test(
+        document.getElementById("vault-feedback").textContent))
+    assert.equal(requests.some((request) => request.action === "scan"), false)
+
+    dom.window.close()
+  })
+
+  test("a stale minimum size failure does not replace a newer successful selection", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const first = 10 * candidateBase ** 2
+    const second = 50 * candidateBase ** 2
+    const currentStatus = fixture([], {
+      candidate_min_bytes: 100 * candidateBase ** 2,
+      global_candidate_min_bytes: 100 * candidateBase ** 2
+    })
+    let statusCount = 0
+    let releaseRecovery
+    const recovery = new Promise((resolve) => { releaseRecovery = resolve })
+    let saveCount = 0
+    const actionResults = {}
+    Object.defineProperty(actionResults, "set_candidate_size", {
+      get() {
+        saveCount += 1
+        return saveCount === 1
+          ? { error: "Could not save minimum file size." }
+          : {}
+      }
+    })
+    const { dom, requests } = await makePage(async () => {
+      statusCount += 1
+      if (statusCount === 2) await recovery
+      return currentStatus
+    }, { actionResults })
+    const document = dom.window.document
+
+    document.querySelector(`[data-candidate-size="${first}"]`).click()
+    await waitFor(() => statusCount === 2)
+    document.querySelector(`[data-candidate-size="${second}"]`).click()
+    releaseRecovery()
+
+    await waitFor(() => requests.filter((request) =>
+      request.action === "set_candidate_size").length === 2)
+    await settle()
+    assert.match(document.getElementById("vault-scan-size-label").textContent,
+      /50 MB\+/)
+    assert.doesNotMatch(document.getElementById("vault-feedback").textContent,
+      /could not save minimum file size/i)
+
+    dom.window.close()
+  })
+
   test("a runtime write denial is reported as cannot deduplicate", async () => {
     const duplicate = item({
       status: "duplicate",
@@ -1090,15 +1191,49 @@ describe("Save Space interface", () => {
       request.action === "find_folders"))
     assert.equal(requests.find((entry) =>
       entry.action === "find_folders").path, "/Users/test")
-    assert.equal(requests.find((entry) =>
-      entry.action === "find_folders").candidate_size,
-      selectedThreshold)
+    const savedIndex = requests.findIndex((request) =>
+      request.action === "set_candidate_size")
+    const findIndex = requests.findIndex((request) =>
+      request.action === "find_folders")
+    assert.ok(savedIndex >= 0 && savedIndex < findIndex)
+    assert.equal("candidate_size" in requests[findIndex], false)
     assert.equal(pickerRequests.length, 0)
     await waitFor(() => document.getElementById(
       "vault-find-overlay").hidden)
     dom.window.close()
   })
 
+  test("a rejected minimum size save blocks pending folder discovery", async () => {
+    const candidateBase = process.platform === "win32" ? 1024 : 1000
+    const saved = 100 * candidateBase ** 2
+    const selected = 50 * candidateBase ** 2
+    const { dom, requests } = await makePage(fixture([item()], {
+      candidate_min_bytes: saved,
+      global_candidate_min_bytes: saved
+    }), {
+      actionResults: {
+        set_candidate_size: { error: "Could not save minimum file size." }
+      }
+    })
+    const document = dom.window.document
+
+    document.getElementById("btn-find-folders").click()
+    await waitFor(() => document.querySelector("[data-find-home-folder]"))
+    const selector = document.getElementById("vault-find-candidate-size")
+    selector.value = String(selected)
+    selector.dispatchEvent(new dom.window.Event("change", { bubbles: true }))
+    document.querySelector("[data-find-home-folder]").click()
+
+    await waitFor(() => document.getElementById(
+      "vault-find-candidate-size").value === String(saved) &&
+      /could not save minimum file size/i.test(
+        document.getElementById("vault-feedback").textContent))
+    assert.equal(requests.some((request) =>
+      request.action === "find_folders"), false)
+
+    dom.window.close()
+  })
+
   test("Find folders explains when a lower threshold needs a global scan", async () => {
     const message = "Run a global scan with this minimum file size before searching folders."
     const { dom, requests } = await makePage(fixture([item()]), {
@@ -1121,9 +1256,8 @@ describe("Save Space interface", () => {
     assert.equal(document.querySelector(
       ".vault-find-partial[role='alert']").textContent.trim(), message)
     assert.ok(document.querySelector("[data-find-home-folder]"))
-    assert.equal(requests.find((request) =>
-      request.action === "find_folders").candidate_size,
-      50 * candidateBase ** 2)
+    assert.equal("candidate_size" in requests.find((request) =>
+      request.action === "find_folders"), false)
     dom.window.close()
   })