pinokiod 8.0.16 → 8.0.18

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

@@ -820,12 +820,9 @@ 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
@@ -839,6 +836,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       })
       return
     }
+    setInstallStatus("<b>Installing tools...</b><br>Starting the fresh installation.")
   }
   term.onData((data) => {
     if (shell_id) {
@@ -889,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

@@ -425,6 +425,53 @@ test('Conda install keeps the old runtime when the replacement installer downloa
   assert.equal(await pathExists(oldRuntimeFile), true)
 })
 
+test('Conda waits for runtime removal before starting the installer', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-removal-order-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root, 'win32')
+  const events = []
+  const output = []
+  let releaseRemoval
+  let removalStarted
+  const removalGate = new Promise((resolve) => { releaseRemoval = resolve })
+  const removalStartedPromise = new Promise((resolve) => { removalStarted = resolve })
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => events.push('download')
+  kernel.bin.rm = async () => events.push('installer-cleanup')
+  kernel.bin.exec = async (payload) => {
+    events.push(payload && payload.conda && payload.conda.skip ? 'installer' : 'conda-install')
+    if (payload && payload.conda && payload.conda.skip) {
+      await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+      await fs.writeFile(path.join(root, 'bin', 'miniforge', 'python.exe'), 'fake python\n')
+    }
+  }
+
+  const conda = createConda(kernel)
+  const removeInstallPath = conda.removeInstallPath.bind(conda)
+  conda.removeInstallPath = async (...args) => {
+    events.push('remove-start')
+    removalStarted()
+    await removalGate
+    await removeInstallPath(...args)
+    events.push('remove-complete')
+  }
+
+  const installation = conda._install({ dependencies: [] }, (data) => {
+    if (data && data.raw) output.push(data.raw)
+  })
+  await removalStartedPromise
+
+  assert.deepEqual(events, ['download', 'remove-start'])
+  assert.match(output.join(''), /removing existing Miniforge installation/)
+
+  releaseRemoval()
+  await installation
+
+  assert.ok(events.indexOf('remove-complete') < events.indexOf('installer'))
+  assert.match(output.join(''), /existing Miniforge installation removed/)
+})
+
 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,9 +479,69 @@ 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",
     fields: { requirements, callback: "/tools" },
   })
 })
+
+test("fresh install shows removal status and waits for cleanup before starting", async (t) => {
+  const source = await fs.readFile(installViewPath, "utf8")
+  const html = ejs.render(source, {
+    agent: "web",
+    callback: "/tools",
+    requirements: '[{"name":"conda"}]',
+    theme: "dark",
+  }, { filename: installViewPath })
+
+  let cleanupStarted = false
+  let resolveCleanup
+  let socketStarted = false
+  const cleanup = new Promise((resolve) => { resolveCleanup = resolve })
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/pinokio/install?fresh=1",
+    beforeParse(window) {
+      window.fetch = async () => ({ json: async () => ({ config: {} }) })
+      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+      window.ResizeObserver = class { observe() {} }
+      window.N = class { Noty() {} }
+      window.Terminal = class {
+        constructor() { this.cols = 80; this.rows = 24 }
+        attachCustomKeyEventHandler() {}
+        focus() {}
+        hasSelection() { return false }
+        loadAddon() {}
+        onData() {}
+        open() {}
+        write() {}
+      }
+      window.FitAddon = { FitAddon: class { fit() {} } }
+      window.WebLinksAddon = { WebLinksAddon: class {} }
+      window.xtermTheme = { FrontEndDelight: {} }
+      window.PinokioTouch = { bindTerminalFocus() {} }
+      window.PinokioPathRemoval = {
+        remove: async () => {
+          cleanupStarted = true
+          return await cleanup
+        },
+      }
+      window.Socket = class {
+        emit() {}
+        run() { socketStarted = true }
+      }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await waitFor(() => cleanupStarted, "fresh cleanup request")
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /Removing existing tools/)
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /take a minute on Windows/)
+  assert.equal(socketStarted, false)
+
+  resolveCleanup({ success: true })
+  await waitFor(() => socketStarted, "installer socket")
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /Installing tools/)
+})