pinokiod 8.0.11 → 8.0.13

package/kernel/path_removal.js

@@ -3,6 +3,7 @@ const path = require("path")
 const { inspectWindowsFileLocks } = require("./windows_restart_manager")
 
 const PATH_REMOVAL_BLOCKED_CODE = "PINOKIO_PATH_REMOVE_BLOCKED"
+const PATH_REMOVAL_PENDING_CODE = "PINOKIO_PATH_REMOVE_PENDING"
 const REMAINING_PREVIEW_LIMIT = 20
 
 class PathRemovalBlockedError extends Error {
@@ -38,7 +39,17 @@ class PathRemovalBlockedError extends Error {
   }
 }
 
+class PathRemovalPendingError extends Error {
+  constructor(target, cause) {
+    super(`Windows still could not remove ${target}.`)
+    this.name = "PathRemovalPendingError"
+    this.code = PATH_REMOVAL_PENDING_CODE
+    this.cause = cause
+  }
+}
+
 const isPathRemovalBlockedError = (error) => !!(error && error.code === PATH_REMOVAL_BLOCKED_CODE)
+const isPathRemovalPendingError = (error) => !!(error && error.code === PATH_REMOVAL_PENDING_CODE)
 
 const collectRemaining = async (target, fsPromises = fs.promises) => {
   const files = []
@@ -87,43 +98,30 @@ const createPathRemover = (dependencies = {}) => {
     const resolvedTarget = path.resolve(target)
     const {
       operation = "Removing files",
+      diagnose = true,
       ...rmOptions
     } = options
-    const trace = (stage, details = "") => {
-      if (platform === "win32") {
-        console.log(`[path removal] ${stage} target=${resolvedTarget}${details ? ` ${details}` : ""}`)
-      }
-    }
 
-    const removeStartedAt = Date.now()
-    trace("rm:start")
     try {
       await fsPromises.rm(resolvedTarget, rmOptions)
-      trace("rm:done", `elapsedMs=${Date.now() - removeStartedAt}`)
       return { removed: true, target: resolvedTarget }
     } catch (error) {
       if (platform !== "win32") {
         throw error
       }
-      trace("rm:failed", `elapsedMs=${Date.now() - removeStartedAt} code=${error && error.code ? error.code : "unknown"}`)
+      if (!diagnose) {
+        throw new PathRemovalPendingError(resolvedTarget, error)
+      }
 
-      const scanStartedAt = Date.now()
-      trace("scan:start")
       const remaining = await collectRemaining(resolvedTarget, fsPromises)
-      trace("scan:done", `elapsedMs=${Date.now() - scanStartedAt} paths=${remaining.paths.length} files=${remaining.files.length}`)
       if (remaining.paths.length === 0) {
         throw error
       }
 
       let inspection = { blockers: [] }
-      const inspectionStartedAt = Date.now()
-      trace("restart-manager:start", `files=${remaining.files.length}`)
       try {
         inspection = await inspectLocks(remaining.files)
-        const blockerCount = Array.isArray(inspection && inspection.blockers) ? inspection.blockers.length : 0
-        trace("restart-manager:done", `elapsedMs=${Date.now() - inspectionStartedAt} blockers=${blockerCount}`)
       } catch (inspectionError) {
-        trace("restart-manager:failed", `elapsedMs=${Date.now() - inspectionStartedAt} message=${inspectionError && inspectionError.message ? inspectionError.message : String(inspectionError)}`)
         console.warn("[path removal] Restart Manager inspection failed", inspectionError)
       }
 
@@ -143,8 +141,10 @@ const removePath = createPathRemover()
 
 module.exports = {
   PATH_REMOVAL_BLOCKED_CODE,
+  PATH_REMOVAL_PENDING_CODE,
   collectRemaining,
   createPathRemover,
   isPathRemovalBlockedError,
+  isPathRemovalPendingError,
   removePath,
 }

package/kernel/windows_restart_manager.js

@@ -17,15 +17,15 @@ const initialize = () => {
   const koffi = require("koffi")
   const library = koffi.load("rstrtmgr.dll")
   const kernel32 = koffi.load("kernel32.dll")
-  const fileTime = koffi.struct("PINOKIO_RM_FILETIME", {
+  const fileTime = koffi.struct({
     dwLowDateTime: "uint32_t",
     dwHighDateTime: "uint32_t",
   })
-  const uniqueProcess = koffi.struct("PINOKIO_RM_UNIQUE_PROCESS", {
+  const uniqueProcess = koffi.struct({
     dwProcessId: "uint32_t",
     ProcessStartTime: fileTime,
   })
-  const processInfo = koffi.struct("PINOKIO_RM_PROCESS_INFO", {
+  const processInfo = koffi.struct({
     Process: uniqueProcess,
     strAppName: koffi.array("char16_t", 256, "String"),
     strServiceShortName: koffi.array("char16_t", 64, "String"),

package/package.json

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

package/server/index.js

@@ -34,7 +34,7 @@ const Git = require("../kernel/git")
 const TerminalApi = require('../kernel/api/terminal')
 const PluginSources = require("../kernel/plugin_sources")
 const ManagedSkills = require("../kernel/managed_skills")
-const { isPathRemovalBlockedError, removePath } = require("../kernel/path_removal")
+const { isPathRemovalBlockedError, isPathRemovalPendingError, removePath } = require("../kernel/path_removal")
 
 const git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -63,6 +63,40 @@ const ex = fn => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
 };
 
+const isPathInsideRoot = (candidatePath, rootPath) => {
+  const relative = path.relative(rootPath, candidatePath)
+  return relative === "" || (
+    relative !== ".."
+    && !relative.startsWith(`..${path.sep}`)
+    && !path.isAbsolute(relative)
+  )
+}
+
+const resolveAppRemovalPath = async (apiRoot, name) => {
+  if (typeof name !== "string" || !name || name.includes("\0")) {
+    return null
+  }
+  const root = path.resolve(apiRoot)
+  const target = path.resolve(root, name)
+  if (target === root || !isPathInsideRoot(target, root)) {
+    return null
+  }
+  const stat = await fs.promises.lstat(target).catch((error) => {
+    if (error && error.code === "ENOENT") return null
+    throw error
+  })
+  if (stat && !stat.isSymbolicLink()) {
+    const [realRoot, realTarget] = await Promise.all([
+      fs.promises.realpath(root),
+      fs.promises.realpath(target),
+    ])
+    if (realTarget === realRoot || !isPathInsideRoot(realTarget, realRoot)) {
+      return null
+    }
+  }
+  return target
+}
+
 
 
 
@@ -16263,6 +16297,10 @@ class Server {
       console.timeEnd("/p/" + req.params.name + "/" + d)
     }))
     this.app.post("/pinokio/delete", ex(async (req, res) => {
+      if (!privacyFilterCache.isInstallRequestAllowed(req)) {
+        res.status(403).json({ error: "Cross-site deletion is not allowed" })
+        return
+      }
       try {
         if (req.body.type === 'conda-runtime') {
           for (const runtimeName of ["miniconda", "miniforge"]) {
@@ -16270,6 +16308,7 @@ class Server {
             await removePath(runtimePath, {
               recursive: true,
               force: true,
+              diagnose: req.body.background !== true,
               operation: "Updating Miniforge",
             })
           }
@@ -16279,15 +16318,18 @@ class Server {
           await removePath(folderPath, {
             recursive: true,
             force: true,
+            diagnose: req.body.background !== true,
             operation: "Resetting managed tools",
           })
           await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
+          await this.kernel.bin.refreshInstalled()
           res.json({ success: true })
         } else if (req.body.type === 'cache') {
           let folderPath = this.kernel.path("cache")
           await removePath(folderPath, {
             recursive: true,
             force: true,
+            diagnose: req.body.background !== true,
             operation: "Clearing the Pinokio cache",
           })
           await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
@@ -16306,10 +16348,15 @@ class Server {
           }
           res.json({ success: true })
         } else if (req.body.name) {
-          let folderPath = this.kernel.path("api", req.body.name)
+          const folderPath = await resolveAppRemovalPath(this.kernel.path("api"), req.body.name)
+          if (!folderPath) {
+            res.status(400).json({ error: "Invalid app deletion path" })
+            return
+          }
           await removePath(folderPath, {
             recursive: true,
             force: true,
+            diagnose: req.body.background !== true,
             operation: `Deleting ${req.body.name}`,
           })
 //          await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
@@ -16322,6 +16369,10 @@ class Server {
           res.json({ success: true })
         }
       } catch(err) {
+        if (isPathRemovalPendingError(err)) {
+          res.status(423).json({ success: false, pending: true })
+          return
+        }
         if (isPathRemovalBlockedError(err)) {
           res.status(423).json({ success: false, error: err.toJSON() })
           return

package/server/public/common.js

@@ -82,7 +82,7 @@ const PinokioPathRemoval = (() => {
         : ""
       throw new Error(text || `Request failed (${response.status || "unknown"})`)
     }
-    if (!response.ok && !blockedDetails(payload)) {
+    if (!response.ok && !blockedDetails(payload) && !(payload && payload.pending === true)) {
       const message = payload && payload.error
       throw new Error(typeof message === "string" ? message : `Request failed (${response.status})`)
     }
@@ -110,15 +110,24 @@ const PinokioPathRemoval = (() => {
 
       const update = () => {
         const container = Swal.getHtmlContainer()
-        if (container) container.innerHTML = render(current)
+        if (container) {
+          const filesOpen = !!container.querySelector(".pinokio-path-blocker-files")?.open
+          container.innerHTML = render(current)
+          const files = container.querySelector(".pinokio-path-blocker-files")
+          if (files) files.open = filesOpen
+        }
       }
 
       const attempt = async (manual = false) => {
         if (retrying || settled || typeof retry !== "function") return false
         retrying = true
-        if (typeof Swal.disableButtons === "function") Swal.disableButtons()
+        if (manual && typeof Swal.disableButtons === "function") Swal.disableButtons()
         try {
-          const result = await retry()
+          const result = await retry(manual)
+          if (settled) return false
+          if (result && result.pending === true) {
+            return false
+          }
           const nextBlocked = blockedDetails(result)
           if (nextBlocked) {
             current = nextBlocked
@@ -133,7 +142,7 @@ const PinokioPathRemoval = (() => {
           return false
         } finally {
           retrying = false
-          if (!settled && typeof Swal.enableButtons === "function") Swal.enableButtons()
+          if (manual && !settled && typeof Swal.enableButtons === "function") Swal.enableButtons()
         }
       }
 
@@ -164,7 +173,7 @@ const PinokioPathRemoval = (() => {
   }
 
   const request = async (requestFactory) => {
-    const execute = async () => parseResponse(await requestFactory())
+    const execute = async (background = false) => parseResponse(await requestFactory(background))
     const initial = await execute()
     const details = blockedDetails(initial)
     if (!details) {
@@ -175,7 +184,7 @@ const PinokioPathRemoval = (() => {
     }
     return show({
       details,
-      retry: execute,
+      retry: (manual) => execute(!manual),
     })
   }
 

package/server/views/app.ejs

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

package/server/views/download.ejs

@@ -231,12 +231,12 @@ 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(() => fetch("/pinokio/delete", {
+        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
           method: "post",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify({ type: "bin" })
+          body: JSON.stringify({ type: "bin", background })
         }))
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")

package/server/views/editor.ejs

@@ -940,12 +940,12 @@ 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(() => fetch("/pinokio/delete", {
+        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
           method: "post",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify({ type: "bin" })
+          body: JSON.stringify({ type: "bin", background })
         }))
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")

package/server/views/env_editor.ejs

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

package/server/views/file_explorer.ejs

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

package/server/views/index.ejs

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

package/server/views/install.ejs

@@ -731,6 +731,20 @@ const navigateToCallback = () => {
   }
   location.href = href
 }
+const resumeInstall = () => {
+  const form = document.createElement("form")
+  form.method = "post"
+  form.action = "/pinokio/install"
+  for (const name of ["requirements", "callback"]) {
+    const input = document.createElement("input")
+    input.type = "hidden"
+    input.name = name
+    input.value = document.querySelector(`#${name}`).value
+    form.appendChild(input)
+  }
+  document.body.appendChild(form)
+  form.submit()
+}
 const createTerm = async (_theme) => {
   //const theme = Object.assign({ }, xtermTheme.Terminal_Basic, {
   const theme = Object.assign({ }, _theme, {
@@ -854,13 +868,13 @@ document.addEventListener("DOMContentLoaded", async () => {
       } else if (packet.type === "path.remove.blocked") {
         const result = await PinokioPathRemoval.show({
           details: packet.data,
-          retry: async () => {
+          retry: async (manual) => {
             const response = await fetch("/pinokio/delete", {
               method: "post",
               headers: {
                 "Content-Type": "application/json"
               },
-              body: JSON.stringify({ type: "conda-runtime" })
+              body: JSON.stringify({ type: "conda-runtime", background: !manual })
             })
             const payload = await response.json()
             const blocked = PinokioPathRemoval.blockedDetails(payload)
@@ -872,7 +886,7 @@ document.addEventListener("DOMContentLoaded", async () => {
           }
         })
         if (result && result.success) {
-          setTimeout(() => window.location.reload(), 0)
+          resumeInstall()
         } else if (result && result.cancelled) {
           navigateToCallback()
         }

package/server/views/net.ejs

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

package/server/views/settings.ejs

@@ -1537,12 +1537,12 @@ 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(() => fetch("/pinokio/delete", {
+        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
           method: "post",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify({ type: "bin" })
+          body: JSON.stringify({ type: "bin", background })
         }))
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")
@@ -1561,12 +1561,12 @@ 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(() => fetch("/pinokio/delete", {
+        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
           method: "post",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify({ type: "cache" })
+          body: JSON.stringify({ type: "cache", background })
         }))
         console.log(res)
         document.querySelector(".reset-cache-loading").classList.add("hidden")

package/server/views/setup.ejs

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

package/server/views/terminal.ejs

@@ -3339,12 +3339,12 @@ 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(() => fetch("/pinokio/delete", {
+        let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
           method: "post",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify({ type: "bin" })
+          body: JSON.stringify({ type: "bin", background })
         }))
         console.log(res)
         document.querySelector(".reset-bin-loading").classList.add("hidden")

package/server/views/tools.ejs

@@ -154,6 +154,9 @@
       justify-items: end;
       min-width: 118px;
     }
+    body.tools-page .tools-reinstall-form {
+      margin: 0;
+    }
     body.tools-page .tools-bundle-status {
       display: inline-flex;
       align-items: center;
@@ -494,6 +497,15 @@
                             <i class="fa-solid fa-download" aria-hidden="true"></i>
                             <span>Install</span>
                           </a>
+                        <% } else { %>
+                          <form class="tools-reinstall-form" method="post" action="/pinokio/install">
+                            <input type="hidden" name="requirements" value="<%= JSON.stringify(bundle.requirements) %>">
+                            <input type="hidden" name="callback" value="/tools">
+                            <button class="task-link-button" type="button" data-tools-reinstall data-bundle-title="<%= bundle.title %>">
+                              <i class="fa-solid fa-rotate" aria-hidden="true"></i>
+                              <span>Reinstall</span>
+                            </button>
+                          </form>
                         <% } %>
                       </div>
                     </article>
@@ -828,6 +840,46 @@
       });
     };
 
+    const registerToolsReinstall = () => {
+      document.querySelectorAll("[data-tools-reinstall]").forEach((button) => {
+        button.addEventListener("click", async () => {
+          const bundleTitle = button.dataset.bundleTitle || "this bundle";
+          const proceed = confirm(`Reinstall ${bundleTitle} from scratch? This removes the entire managed tools folder before reinstalling the selected bundle.`);
+          if (!proceed) return;
+
+          const form = button.closest("form");
+          const icon = button.querySelector("i");
+          const restoreButton = () => {
+            button.disabled = false;
+            button.removeAttribute("aria-busy");
+            if (icon) icon.classList.remove("fa-spin");
+          };
+          button.disabled = true;
+          button.setAttribute("aria-busy", "true");
+          if (icon) icon.classList.add("fa-spin");
+          let result;
+          try {
+            result = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
+              method: "post",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ type: "bin", background })
+            }));
+          } catch (error) {
+            restoreButton();
+            alert(error && error.message ? error.message : "Unable to reset managed tools.");
+            return;
+          }
+
+          if (result.cancelled || result.error) {
+            restoreButton();
+            if (result.error) alert(result.error);
+            return;
+          }
+          form.submit();
+        });
+      });
+    };
+
     document.addEventListener("DOMContentLoaded", function() {
       const isPending = <%= pending ? 'true' : 'false' %>;
 
@@ -840,6 +892,7 @@
 
       registerPackageInstallSheets();
       registerPackageInstallForms();
+      registerToolsReinstall();
 
       const tabs = document.querySelectorAll(".tools-tab-button");
       const panels = document.querySelectorAll(".tools-package-panel");

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

@@ -2,10 +2,12 @@ const assert = require("node:assert/strict")
 const fs = require("node:fs/promises")
 const path = require("node:path")
 const test = require("node:test")
+const ejs = require("ejs")
 const { JSDOM, VirtualConsole } = require("jsdom")
 
 const repoRoot = path.resolve(__dirname, "..")
 const commonScriptPath = path.join(repoRoot, "server/public/common.js")
+const installViewPath = path.join(repoRoot, "server/views/install.ejs")
 
 async function waitFor(predicate, message = "condition") {
   const deadline = Date.now() + 1000
@@ -196,12 +198,14 @@ test("path-removal request retries automatically without overlapping and resolve
   t.after(() => dom.window.close())
 
   let requestCount = 0
+  const backgroundRequests = []
   let resolveRetry
   const retryResponse = new Promise((resolve) => {
     resolveRetry = resolve
   })
-  const resultPromise = api.request(async () => {
+  const resultPromise = api.request(async (background) => {
     requestCount += 1
+    backgroundRequests.push(background)
     if (requestCount === 1) {
       return response({
         success: false,
@@ -221,10 +225,10 @@ test("path-removal request retries automatically without overlapping and resolve
   await waitFor(() => state.fireOptions, "path-removal modal")
   const intervalId = state.getRetryIntervalId()
   assert.equal(state.intervals.get(intervalId).delay, 2000)
+  state.htmlContainer.querySelector(".pinokio-path-blocker-files").open = true
 
   const firstAttempt = state.runInterval()
-  assert.equal(state.buttonsDisabled, true)
-  assert.equal(state.dismiss(), false, "Stop must be unavailable during an active removal")
+  assert.equal(state.buttonsDisabled, false)
   assert.equal(state.visible, true)
   await state.runInterval()
   assert.equal(requestCount, 2, "a pending retry must suppress overlapping retries")
@@ -241,6 +245,7 @@ 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/)
 
@@ -248,11 +253,78 @@ test("path-removal request retries automatically without overlapping and resolve
   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) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+
+  let requestCount = 0
+  const shown = api.request(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 })
+  })
+
+  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/)
+
+  state.dismiss()
+  assert.equal((await shown).cancelled, true)
+})
+
+test("Stop remains available during a background retry and ignores its late response", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+
+  let resolveRetry
+  const retryResponse = new Promise((resolve) => {
+    resolveRetry = resolve
+  })
+  const shown = api.show({
+    details: {
+      operation: "Delete app",
+      blockers: [{ name: "Original blocker", pid: 10 }],
+      remainingCount: 1,
+      remaining: ["C:\\app\\original.dll"],
+    },
+    retry: async () => await retryResponse,
+  })
+
+  const attempt = state.runInterval()
+  assert.equal(state.buttonsDisabled, false)
+  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"],
+  })
+  await attempt
+
+  assert.equal((await shown).cancelled, true)
+  assert.match(state.htmlContainer.textContent, /Original blocker/)
+  assert.doesNotMatch(state.htmlContainer.textContent, /Late blocker/)
+})
+
 test("manual retry keeps the modal open when blocked and Stop cancels future retries", async (t) => {
   const { api, dom, state } = await createHarness()
   t.after(() => dom.window.close())
@@ -314,3 +386,74 @@ test("manual retry escapes unexpected error messages", async (t) => {
   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"}]'
+  const html = ejs.render(source, {
+    agent: "web",
+    callback: "/tools",
+    requirements,
+    theme: "dark",
+  }, { filename: installViewPath })
+
+  let rpc
+  let submission
+  let submitted
+  const submittedPromise = new Promise((resolve) => { submitted = resolve })
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/pinokio/install",
+    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 = {
+        blockedDetails: () => null,
+        show: async () => ({ success: true }),
+      }
+      window.Socket = class {
+        emit() {}
+        run(request, onpacket) {
+          rpc = request
+          window.setTimeout(() => onpacket({
+            type: "path.remove.blocked",
+            data: { code: "PINOKIO_PATH_REMOVE_BLOCKED" },
+          }), 0)
+        }
+      }
+      window.HTMLFormElement.prototype.submit = function () {
+        submission = {
+          method: this.method,
+          pathname: new URL(this.action).pathname,
+          fields: Object.fromEntries(new window.FormData(this)),
+        }
+        submitted()
+      }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await submittedPromise
+  assert.equal(rpc.params, requirements)
+  assert.deepEqual(submission, {
+    method: "post",
+    pathname: "/pinokio/install",
+    fields: { requirements, callback: "/tools" },
+  })
+})

package/test/path-removal.test.js

@@ -6,6 +6,7 @@ const path = require("path")
 
 const {
   PATH_REMOVAL_BLOCKED_CODE,
+  PATH_REMOVAL_PENDING_CODE,
   collectRemaining,
   createPathRemover,
 } = require("../kernel/path_removal")
@@ -105,6 +106,30 @@ test("removePath reports Windows blockers after partial recursive deletion and s
   assert.equal(await fs.promises.access(root).then(() => true).catch(() => false), false)
 })
 
+test("background retry attempts removal without repeating diagnostics", async () => {
+  let inspected = false
+  let scanned = false
+  const removePath = createPathRemover({
+    platform: "win32",
+    fsPromises: {
+      rm: async () => { throw Object.assign(new Error("busy"), { code: "EPERM" }) },
+      lstat: async () => { scanned = true },
+      readdir: async () => [],
+    },
+    inspectLocks: async () => {
+      inspected = true
+      return { blockers: [] }
+    },
+  })
+
+  await assert.rejects(
+    removePath("C:\\pinokio\\bin", { recursive: true, force: true, diagnose: false }),
+    (error) => error.code === PATH_REMOVAL_PENDING_CODE,
+  )
+  assert.equal(scanned, false)
+  assert.equal(inspected, false)
+})
+
 test("removePath reports and logs an unattributed Windows removal failure without claiming a file lock", async (t) => {
   const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-remove-denied-"))
   t.after(() => fs.promises.rm(root, { recursive: true, force: true }))

package/test/startup-git-index-route.test.js

@@ -420,6 +420,58 @@ if (!serverMode) test('/pinokio/delete refreshes top-level git URI inventory aft
   })
 })
 
+if (!serverMode) test('/pinokio/delete rejects app paths outside the API root', async () => {
+  await withRouteServer(async ({ baseUrl, root, apiRoot }) => {
+    const outside = path.join(root, 'outside')
+    const outsideFile = path.join(outside, 'keep.txt')
+    await fsp.mkdir(outside, { recursive: true })
+    await fsp.writeFile(outsideFile, 'keep')
+
+    for (const name of ['../../outside', outside]) {
+      const result = await fetchJson(baseUrl, '/pinokio/delete', {
+        method: 'POST',
+        body: { name },
+      })
+      assert.equal(result.response.status, 400)
+      assert.equal(result.json.error, 'Invalid app deletion path')
+      await fsp.access(outsideFile)
+    }
+
+    const linked = path.join(apiRoot, 'linked-outside')
+    await fsp.symlink(outside, linked, process.platform === 'win32' ? 'junction' : 'dir')
+    const linkedResult = await fetchJson(baseUrl, '/pinokio/delete', {
+      method: 'POST',
+      body: { name: 'linked-outside/keep.txt' },
+    })
+    assert.equal(linkedResult.response.status, 400)
+    await fsp.access(outsideFile)
+
+    const crossSiteTarget = path.join(apiRoot, 'cross-site-target')
+    await fsp.mkdir(crossSiteTarget)
+    const crossSiteResult = await fetchJson(baseUrl, '/pinokio/delete', {
+      method: 'POST',
+      headers: { 'sec-fetch-site': 'cross-site' },
+      body: { name: 'cross-site-target' },
+    })
+    assert.equal(crossSiteResult.response.status, 403)
+    await fsp.access(crossSiteTarget)
+
+    const sameSiteTarget = path.join(apiRoot, 'same-site-target')
+    await fsp.mkdir(sameSiteTarget)
+    const sameSiteResult = await fetchJson(baseUrl, '/pinokio/delete', {
+      method: 'POST',
+      headers: {
+        host: new URL(baseUrl).host,
+        origin: 'http://localhost:5173',
+        'sec-fetch-site': 'same-site',
+      },
+      body: { name: 'same-site-target' },
+    })
+    assert.equal(sameSiteResult.response.status, 403)
+    await fsp.access(sameSiteTarget)
+  })
+})
+
 if (!serverMode) test('/pinokio/upload move refreshes top-level git URI inventory', async () => {
   await withRouteServer(async ({
     baseUrl,

package/test/tools-reinstall-ui.test.js

@@ -0,0 +1,104 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const ejs = require("ejs")
+const { JSDOM } = require("jsdom")
+
+const viewPath = path.resolve(__dirname, "../server/views/tools.ejs")
+
+async function renderTools() {
+  const source = await fs.readFile(viewPath, "utf8")
+  return ejs.render(source, {
+    agent: "web",
+    bundles: [{
+      name: "dev",
+      title: "Coding (Essential)",
+      description: "Essential tools",
+      install_required: false,
+      requirements: [{ name: "conda", type: "bin", installed: true }],
+    }],
+    installs: [],
+    pending: false,
+    theme: "dark",
+  }, {
+    filename: viewPath,
+    includer: () => ({ template: "" }),
+  })
+}
+
+test("Tools reinstall removes bin and submits the selected bundle", async (t) => {
+  const html = await renderTools()
+  let request
+  let submission
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/tools",
+    beforeParse(window) {
+      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+      window.requestAnimationFrame = (callback) => window.setTimeout(callback, 0)
+      window.confirm = () => true
+      window.PinokioPathRemoval = {
+        request: async (remove) => {
+          request = await remove(false)
+          return { success: true }
+        },
+      }
+      window.fetch = async (url, options) => ({ url, options })
+      window.HTMLFormElement.prototype.submit = function () {
+        submission = {
+          action: new URL(this.action).pathname,
+          fields: Object.fromEntries(new window.FormData(this)),
+        }
+      }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
+  const button = dom.window.document.querySelector("[data-tools-reinstall]")
+  assert.ok(button)
+  button.click()
+  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
+
+  assert.equal(request.url, "/pinokio/delete")
+  assert.equal(request.options.method, "post")
+  assert.deepEqual(JSON.parse(request.options.body), { type: "bin", background: false })
+  assert.deepEqual(submission, {
+    action: "/pinokio/install",
+    fields: {
+      requirements: '[{"name":"conda","type":"bin","installed":true}]',
+      callback: "/tools",
+    },
+  })
+})
+
+test("Tools reinstall keeps the bundle intact when the user cancels", async (t) => {
+  const html = await renderTools()
+  let removed = false
+  let submitted = false
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/tools",
+    beforeParse(window) {
+      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+      window.requestAnimationFrame = (callback) => window.setTimeout(callback, 0)
+      window.fetch = async () => ({ ok: true, json: async () => ({ status: "off" }) })
+      window.confirm = () => false
+      window.PinokioPathRemoval = {
+        request: async () => {
+          removed = true
+          return { success: true }
+        },
+      }
+      window.HTMLFormElement.prototype.submit = () => { submitted = true }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
+  dom.window.document.querySelector("[data-tools-reinstall]").click()
+  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
+  assert.equal(removed, false)
+  assert.equal(submitted, false)
+})

package/test/windows-path-removal.integration.test.js

@@ -68,6 +68,12 @@ test("Windows integration: loaded DLL is diagnosed and removable after release",
   )
   assert.equal(await fs.promises.access(ordinaryFile).then(() => true).catch(() => false), false)
 
+  const restartManagerPath = require.resolve("../kernel/windows_restart_manager")
+  delete require.cache[restartManagerPath]
+  const reloadedRestartManager = require(restartManagerPath)
+  const reloadedInspection = await reloadedRestartManager.inspectWindowsFileLocks([dllPath])
+  assert.equal(reloadedInspection.blockers.some((blocker) => blocker.pid === child.pid), true)
+
   const exited = new Promise((resolve) => child.once("exit", resolve))
   child.stdin.write("release\n")
   await exited