pinokiod 8.0.17 → 8.0.18

package/server/views/app.ejs

@@ -11866,13 +11866,7 @@ const rerenderMenuSection = (container, html) => {
             actions: "hidden"
           }
         });
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ name, background })
-        }))
+        let res = await PinokioPathRemoval.remove({ name })
         console.log("res", res)
         Swal.close()
         if (res) {

package/server/views/download.ejs

@@ -231,13 +231,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (proceed) {
         document.querySelector(".reset-bin-loading").classList.remove("hidden")
         document.querySelector("#del-bin").classList.add("hidden")
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ type: "bin", background })
-        }))
+        let res = await PinokioPathRemoval.remove({ type: "bin" })
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")
         if (res.cancelled) {

package/server/views/editor.ejs

@@ -940,13 +940,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (proceed) {
         document.querySelector(".reset-bin-loading").classList.remove("hidden")
         document.querySelector("#del-bin").classList.add("hidden")
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ type: "bin", background })
-        }))
+        let res = await PinokioPathRemoval.remove({ type: "bin" })
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")
         if (res.cancelled) {

package/server/views/env_editor.ejs

@@ -447,13 +447,7 @@ document.addEventListener("DOMContentLoaded", async () => {
           }
         })
         try {
-          const res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-            method: "post",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({ name: projectName, background })
-          }))
+          const res = await PinokioPathRemoval.remove({ name: projectName })
           Swal.close()
           if (res && res.success) {
             navigateHome()

package/server/views/file_explorer.ejs

@@ -636,13 +636,7 @@ document.addEventListener("click", async (e) => {
           actions: "hidden"
         }
       });
-      let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-        method: "post",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ name, background })
-      }))
+      let res = await PinokioPathRemoval.remove({ name })
       console.log("res", res)
       Swal.close()
       if (res) {

package/server/views/index.ejs

@@ -4031,13 +4031,7 @@ document.addEventListener("click", async (e) => {
           actions: "hidden"
         }
       });
-      let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-        method: "post",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ name, background })
-      }))
+      let res = await PinokioPathRemoval.remove({ name })
       console.log("res", res)
       Swal.close()
       if (res) {

package/server/views/install.ejs

@@ -822,11 +822,7 @@ document.addEventListener("DOMContentLoaded", async () => {
   if (options && options.fresh === "1") {
     setInstallStatus("<b>Removing existing tools...</b><br>This can take a minute on Windows.")
     try {
-      const result = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-        method: "post",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ type: "bin", background })
-      }))
+      const result = await PinokioPathRemoval.remove({ type: "bin" })
       if (result.cancelled) {
         navigateToCallback()
         return
@@ -891,22 +887,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       } else if (packet.type === "path.remove.blocked") {
         const result = await PinokioPathRemoval.show({
           details: packet.data,
-          retry: async (manual) => {
-            const response = await fetch("/pinokio/delete", {
-              method: "post",
-              headers: {
-                "Content-Type": "application/json"
-              },
-              body: JSON.stringify({ type: "conda-runtime", background: !manual })
-            })
-            const payload = await response.json()
-            const blocked = PinokioPathRemoval.blockedDetails(payload)
-            if (!blocked && (!response.ok || (payload && payload.error))) {
-              const message = payload && payload.error
-              throw new Error(typeof message === "string" ? message : `Cleanup failed (${response.status})`)
-            }
-            return payload
-          }
+          retry: () => PinokioPathRemoval.tryRemove({ type: "conda-runtime" })
         })
         if (result && result.success) {
           resumeInstall()

package/server/views/net.ejs

@@ -2361,13 +2361,7 @@ document.addEventListener("click", async (e) => {
           actions: "hidden"
         }
       });
-      let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-        method: "post",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ name, background })
-      }))
+      let res = await PinokioPathRemoval.remove({ name })
       console.log("res", res)
       Swal.close()
       if (res) {

package/server/views/settings.ejs

@@ -1537,13 +1537,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (proceed) {
         document.querySelector(".reset-bin-loading").classList.remove("hidden")
         document.querySelector("#del-bin").classList.add("hidden")
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ type: "bin", background })
-        }))
+        let res = await PinokioPathRemoval.remove({ type: "bin" })
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")
         if (res.cancelled) {
@@ -1561,13 +1555,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (proceed) {
         document.querySelector(".reset-cache-loading").classList.remove("hidden")
         document.querySelector("#del-cache").classList.add("hidden")
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ type: "cache", background })
-        }))
+        let res = await PinokioPathRemoval.remove({ type: "cache" })
         console.log(res)
         document.querySelector(".reset-cache-loading").classList.add("hidden")
         if (res.cancelled) {

package/server/views/terminal.ejs

@@ -3339,13 +3339,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       if (proceed) {
         document.querySelector(".reset-bin-loading").classList.remove("hidden")
         document.querySelector("#del-bin").classList.add("hidden")
-        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-          method: "post",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ type: "bin", background })
-        }))
+        let res = await PinokioPathRemoval.remove({ type: "bin" })
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")
         if (res.cancelled) {

package/test/conda-bin.test.js

@@ -472,37 +472,6 @@ test('Conda waits for runtime removal before starting the installer', async () =
   assert.match(output.join(''), /existing Miniforge installation removed/)
 })
 
-test('Bin serializes concurrent installs without dropping either request', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-bin-install-single-flight-'))
-  const bin = createBin(root)
-  const events = []
-  let release
-  const gate = new Promise((resolve) => { release = resolve })
-
-  bin.installRequirements = async (req) => {
-    events.push(`start:${req.id}`)
-    if (req.id === 'first') await gate
-    events.push(`finish:${req.id}`)
-    return req.id
-  }
-
-  const first = bin.install({ id: 'first' }, () => {})
-  const second = bin.install({ id: 'second' }, () => {})
-  await Promise.resolve()
-  assert.deepEqual(events, ['start:first'])
-
-  release()
-  assert.deepEqual(await Promise.all([first, second]), ['first', 'second'])
-  assert.deepEqual(events, ['start:first', 'finish:first', 'start:second', 'finish:second'])
-
-  bin.installRequirements = async (req) => {
-    if (req.id === 'failure') throw new Error('install failed')
-    return req.id
-  }
-  await assert.rejects(bin.install({ id: 'failure' }, () => {}), /install failed/)
-  assert.equal(await bin.install({ id: 'after-failure' }, () => {}), 'after-failure')
-})
-
 test('Conda install propagates bootstrap failure after replacing the runtime', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-bootstrap-fails-'))
   await createMiniforge(root)

package/test/path-removal-ui.test.js

@@ -142,10 +142,9 @@ test("path-removal modal renders identified blockers and escapes backend text",
 
   const shown = api.show({
     details: {
-      operation: "Delete <app>",
       blockers: [{
         name: "G <HUB>",
-        executable: "C:\\Program Files\\G & HUB\\lghub.exe",
+        serviceName: "lghub-service",
         pid: 4321,
       }],
       remainingCount: 25,
@@ -154,10 +153,11 @@ test("path-removal modal renders identified blockers and escapes backend text",
     retry: async () => ({ ok: true }),
   })
 
-  assert.equal(state.fireOptions.title, "Delete &lt;app&gt;")
+  assert.equal(state.fireOptions.title, "File removal paused")
   assert.match(state.htmlContainer.innerHTML, /G &lt;HUB&gt;/)
   assert.doesNotMatch(state.htmlContainer.innerHTML, /G <HUB>/)
-  assert.match(state.htmlContainer.textContent, /C:\\Program Files\\G & HUB\\lghub\.exe · PID 4321/)
+  assert.match(state.htmlContainer.textContent, /lghub-service · PID 4321/)
+  assert.match(state.htmlContainer.textContent, /because one or more files are still in use/)
   assert.match(state.htmlContainer.textContent, /Show first 20 of 25 remaining items/)
   assert.match(state.htmlContainer.textContent, /Close the app above/)
   assert.equal(state.htmlContainer.querySelector(".pinokio-path-blocker-icon"), null)
@@ -175,7 +175,6 @@ test("path-removal modal reports unattributed EACCES without naming an applicati
 
   const shown = api.show({
     details: {
-      operation: "Delete app",
       causeCode: "EACCES",
       blockers: [],
       remainingCount: 1,
@@ -198,20 +197,19 @@ test("path-removal request retries automatically without overlapping and resolve
   t.after(() => dom.window.close())
 
   let requestCount = 0
-  const backgroundRequests = []
+  let firstRequest
   let resolveRetry
   const retryResponse = new Promise((resolve) => {
     resolveRetry = resolve
   })
-  const resultPromise = api.request(async (background) => {
+  dom.window.fetch = async (url, options) => {
     requestCount += 1
-    backgroundRequests.push(background)
+    if (requestCount === 1) firstRequest = { url, options }
     if (requestCount === 1) {
       return response({
         success: false,
         error: {
           code: "PINOKIO_PATH_REMOVE_BLOCKED",
-          operation: "Replace Miniforge",
           blockers: [{ name: "First blocker", pid: 10 }],
           remainingCount: 1,
           remaining: ["C:\\runtime\\first.dll"],
@@ -220,9 +218,13 @@ test("path-removal request retries automatically without overlapping and resolve
     }
     if (requestCount === 2) return await retryResponse
     return response({ ok: true }, { ok: true, status: 200 })
-  })
+  }
+  const resultPromise = api.remove({ type: "bin" })
 
   await waitFor(() => state.fireOptions, "path-removal modal")
+  assert.equal(firstRequest.url, "/pinokio/delete")
+  assert.equal(firstRequest.options.method, "post")
+  assert.deepEqual(JSON.parse(firstRequest.options.body), { type: "bin" })
   const intervalId = state.getRetryIntervalId()
   assert.equal(state.intervals.get(intervalId).delay, 2000)
   state.htmlContainer.querySelector(".pinokio-path-blocker-files").open = true
@@ -237,7 +239,6 @@ test("path-removal request retries automatically without overlapping and resolve
     success: false,
     error: {
       code: "PINOKIO_PATH_REMOVE_BLOCKED",
-      operation: "Replace Miniforge",
       blockers: [{ name: "Second blocker", pid: 20 }],
       remainingCount: 1,
       remaining: ["C:\\runtime\\second.dll"],
@@ -246,45 +247,52 @@ test("path-removal request retries automatically without overlapping and resolve
   await firstAttempt
   assert.equal(state.buttonsDisabled, false)
   assert.equal(state.htmlContainer.querySelector(".pinokio-path-blocker-files").open, true)
-  assert.match(state.htmlContainer.textContent, /Second blocker/)
-  assert.doesNotMatch(state.htmlContainer.textContent, /First blocker/)
+  assert.match(state.htmlContainer.textContent, /First blocker/)
+  assert.doesNotMatch(state.htmlContainer.textContent, /Second blocker/)
 
   await state.runInterval()
   const result = await resultPromise
   assert.equal(result.ok, true)
   assert.equal(requestCount, 3)
-  assert.deepEqual(backgroundRequests, [false, true, true])
   assert.equal(state.closeCount, 1)
   assert.equal(state.intervals.has(intervalId), false)
   assert.ok(state.clearedIntervals.has(intervalId))
 })
 
-test("background pending response keeps the current blocker without rerendering", async (t) => {
+test("background blocked response keeps the current modal without rerendering", async (t) => {
   const { api, dom, state } = await createHarness()
   t.after(() => dom.window.close())
 
   let requestCount = 0
-  const shown = api.request(async () => {
+  dom.window.fetch = async () => {
     requestCount += 1
     if (requestCount === 1) {
       return response({
         error: {
           code: "PINOKIO_PATH_REMOVE_BLOCKED",
-          operation: "Delete app",
           blockers: [{ name: "Original blocker", pid: 10 }],
           remainingCount: 1,
           remaining: ["C:\\app\\locked.dll"],
         },
       })
     }
-    return response({ success: false, pending: true })
-  })
+    return response({
+      error: {
+        code: "PINOKIO_PATH_REMOVE_BLOCKED",
+        blockers: [{ name: "Updated blocker", pid: 20 }],
+        remainingCount: 1,
+        remaining: ["C:\\app\\updated.dll"],
+      },
+    })
+  }
+  const shown = api.remove({ name: "app" })
 
   await waitFor(() => state.fireOptions, "path-removal modal")
   await state.runInterval()
   assert.equal(requestCount, 2)
   assert.equal(state.visible, true)
   assert.match(state.htmlContainer.textContent, /Original blocker/)
+  assert.doesNotMatch(state.htmlContainer.textContent, /Updated blocker/)
 
   state.dismiss()
   assert.equal((await shown).cancelled, true)
@@ -300,7 +308,6 @@ test("Stop remains available during a background retry and ignores its late resp
   })
   const shown = api.show({
     details: {
-      operation: "Delete app",
       blockers: [{ name: "Original blocker", pid: 10 }],
       remainingCount: 1,
       remaining: ["C:\\app\\original.dll"],
@@ -313,7 +320,6 @@ test("Stop remains available during a background retry and ignores its late resp
   assert.equal(state.dismiss(), true)
   resolveRetry({
     code: "PINOKIO_PATH_REMOVE_BLOCKED",
-    operation: "Delete app",
     blockers: [{ name: "Late blocker", pid: 20 }],
     remainingCount: 1,
     remaining: ["C:\\app\\late.dll"],
@@ -332,7 +338,6 @@ test("manual retry keeps the modal open when blocked and Stop cancels future ret
   let retryCount = 0
   const shown = api.show({
     details: {
-      operation: "Delete app",
       blockers: [{ name: "Lock holder", pid: 99 }],
       remainingCount: 1,
       remaining: ["C:\\app\\locked.dll"],
@@ -341,7 +346,6 @@ test("manual retry keeps the modal open when blocked and Stop cancels future ret
       retryCount += 1
       return {
         code: "PINOKIO_PATH_REMOVE_BLOCKED",
-        operation: "Delete app",
         blockers: [{ name: "Lock holder", pid: 99 }],
         remainingCount: 1,
         remaining: ["C:\\app\\locked.dll"],
@@ -369,7 +373,6 @@ test("manual retry escapes unexpected error messages", async (t) => {
 
   const shown = api.show({
     details: {
-      operation: "Delete app",
       blockers: [],
       remainingCount: 1,
       remaining: ["C:\\app\\locked.dll"],
@@ -387,6 +390,27 @@ test("manual retry escapes unexpected error messages", async (t) => {
   assert.equal((await shown).cancelled, true)
 })
 
+test("ordinary retry errors keep the modal open", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+
+  const shown = api.show({
+    details: {
+      blockers: [],
+      remainingCount: 1,
+      remaining: ["C:\\app\\locked.dll"],
+    },
+    retry: async () => ({ error: "Cleanup failed" }),
+  })
+
+  assert.equal(await state.fireOptions.preConfirm(), false)
+  assert.equal(state.visible, true)
+  assert.equal(state.validationMessage, "Cleanup failed")
+
+  state.dismiss()
+  assert.equal((await shown).cancelled, true)
+})
+
 test("successful runtime cleanup resubmits the interrupted install", async (t) => {
   const source = await fs.readFile(installViewPath, "utf8")
   const requirements = '[{"name":"conda"}]'
@@ -398,6 +422,7 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
   }, { filename: installViewPath })
 
   let rpc
+  let cleanupPayload
   let submission
   let submitted
   const submittedPromise = new Promise((resolve) => { submitted = resolve })
@@ -424,8 +449,11 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
       window.xtermTheme = { FrontEndDelight: {} }
       window.PinokioTouch = { bindTerminalFocus() {} }
       window.PinokioPathRemoval = {
-        blockedDetails: () => null,
-        show: async () => ({ success: true }),
+        show: async ({ retry }) => await retry(),
+        tryRemove: async (payload) => {
+          cleanupPayload = payload
+          return { success: true }
+        },
       }
       window.Socket = class {
         emit() {}
@@ -451,6 +479,7 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
 
   await submittedPromise
   assert.equal(rpc.params, requirements)
+  assert.equal(cleanupPayload.type, "conda-runtime")
   assert.deepEqual(submission, {
     method: "post",
     pathname: "/pinokio/install",
@@ -494,7 +523,7 @@ test("fresh install shows removal status and waits for cleanup before starting",
       window.xtermTheme = { FrontEndDelight: {} }
       window.PinokioTouch = { bindTerminalFocus() {} }
       window.PinokioPathRemoval = {
-        request: async () => {
+        remove: async () => {
           cleanupStarted = true
           return await cleanup
         },