pinokiod 8.0.8 → 8.0.10

package/kernel/bin/conda.js

@@ -1,6 +1,7 @@
 const fs = require('fs')
 const { glob } = require('glob')
 const semver = require('semver')
+const { isPathRemovalBlockedError, removePath } = require('../path_removal')
 const { buildCondaListFromMeta, managedCondaRuns } = require('./conda-meta')
 const {
   CONDA_PIN_VERSION,
@@ -171,11 +172,7 @@ report_errors: false`)
     await this.kernel.bin.download(installer_url, installer, ondata)
 
     const caddy = this.kernel.bin.mod && this.kernel.bin.mod.caddy
-    let caddyWasRunning = false
-    if (caddy && typeof caddy.running === "function") {
-      caddyWasRunning = await caddy.running()
-    }
-    if (caddyWasRunning) {
+    if (caddy && typeof caddy.running === "function" && await caddy.running()) {
       ondata({ raw: `stopping Home Server before replacing Miniforge...\r\n` })
       await caddy.stop()
     }
@@ -183,12 +180,12 @@ report_errors: false`)
     legacy_path_exists = await this.kernel.exists(`bin/${LEGACY_CONDA_ROOT_DIR}`)
     if (legacy_path_exists) {
       console.log("Removing legacy install path...", legacy_path)
-      await this.removeInstallPath(legacy_path)
+      await this.removeInstallPath(legacy_path, ondata)
     }
     install_path_exists = await this.kernel.exists(`bin/${CONDA_ROOT_DIR}`)
     if (install_path_exists) {
       console.log("Removing existing install path...", install_path)
-      await this.removeInstallPath(install_path)
+      await this.removeInstallPath(install_path, ondata)
     }
 
     // 2. run the script
@@ -213,9 +210,6 @@ report_errors: false`)
     }
 
     const dependencies = new Set(Array.isArray(req.dependencies) ? req.dependencies : [])
-    if (caddyWasRunning) {
-      dependencies.add("caddy")
-    }
     let mods = this.kernel.bin.mods.filter((m) => {
       return dependencies.has(m.name)
     }).map((m) => {
@@ -255,12 +249,8 @@ report_errors: false`)
     await this.ensureCompatibilityAlias()
     ondata({ raw: `Install finished\r\n` })
     await this.kernel.bin.rm(installer, ondata)
-    if (caddyWasRunning) {
-      ondata({ raw: `restarting Home Server after replacing Miniforge...\r\n` })
-      await caddy.start()
-    }
   }
-  async removeInstallPath(target) {
+  async removeInstallPath(target, ondata) {
     try {
       const stat = await fs.promises.lstat(target).catch((error) => {
         if (error && error.code === "ENOENT") {
@@ -272,16 +262,26 @@ report_errors: false`)
         return
       }
       if (stat.isSymbolicLink()) {
-        await fs.promises.rm(target, { force: true })
+        await removePath(target, {
+          force: true,
+          operation: "Updating Miniforge",
+        })
         return
       }
-      await fs.promises.rm(target, {
+      await removePath(target, {
         recursive: true,
         force: true,
         maxRetries: 5,
         retryDelay: 250,
+        operation: "Updating Miniforge",
       })
     } catch (error) {
+      if (isPathRemovalBlockedError(error)) {
+        if (typeof ondata === "function") {
+          ondata(error.toJSON(), "path.remove.blocked")
+        }
+        throw new Error(`__PINOKIO_BLOCKER__ ${error.message}`)
+      }
       const reason = error && (error.code || error.message) ? error.code || error.message : String(error)
       throw new Error([
         `Pinokio needs to replace the Conda runtime at ${target}, but it could not delete that folder.`,

package/kernel/path_removal.js

@@ -0,0 +1,150 @@
+const fs = require("fs")
+const path = require("path")
+const { inspectWindowsFileLocks } = require("./windows_restart_manager")
+
+const PATH_REMOVAL_BLOCKED_CODE = "PINOKIO_PATH_REMOVE_BLOCKED"
+const REMAINING_PREVIEW_LIMIT = 20
+
+class PathRemovalBlockedError extends Error {
+  constructor(details, cause) {
+    const blockers = Array.isArray(details.blockers) ? details.blockers : []
+    const blockerReason = `${blockers.length === 1 ? "1 application" : `${blockers.length} applications`} may still be using files inside it`
+    super(blockers.length > 0
+      ? `Windows could not remove ${details.target} because ${blockerReason}.`
+      : `Windows could not remove ${details.target}.`)
+    this.name = "PathRemovalBlockedError"
+    this.code = PATH_REMOVAL_BLOCKED_CODE
+    this.target = details.target
+    this.operation = details.operation || "Removing files"
+    this.causeCode = cause && cause.code ? cause.code : ""
+    const remaining = Array.isArray(details.remaining) ? details.remaining : []
+    this.remaining = remaining.slice(0, REMAINING_PREVIEW_LIMIT)
+    this.remainingCount = remaining.length
+    this.blockers = blockers
+    this.cause = cause
+  }
+
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      target: this.target,
+      operation: this.operation,
+      causeCode: this.causeCode,
+      remaining: this.remaining,
+      remainingCount: this.remainingCount,
+      blockers: this.blockers,
+    }
+  }
+}
+
+const isPathRemovalBlockedError = (error) => !!(error && error.code === PATH_REMOVAL_BLOCKED_CODE)
+
+const collectRemaining = async (target, fsPromises = fs.promises) => {
+  const files = []
+  const paths = []
+  const pending = [path.resolve(target)]
+
+  while (pending.length > 0) {
+    const current = pending.pop()
+    let stat
+    try {
+      stat = await fsPromises.lstat(current)
+    } catch (error) {
+      if (error && error.code === "ENOENT") {
+        continue
+      }
+      paths.push(current)
+      continue
+    }
+
+    paths.push(current)
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      files.push(current)
+      continue
+    }
+
+    let entries
+    try {
+      entries = await fsPromises.readdir(current, { withFileTypes: true })
+    } catch (_) {
+      continue
+    }
+    for (const entry of entries) {
+      pending.push(path.resolve(current, entry.name))
+    }
+  }
+
+  return { files, paths }
+}
+
+const createPathRemover = (dependencies = {}) => {
+  const fsPromises = dependencies.fsPromises || fs.promises
+  const platform = dependencies.platform || process.platform
+  const inspectLocks = dependencies.inspectLocks || inspectWindowsFileLocks
+
+  return async (target, options = {}) => {
+    const resolvedTarget = path.resolve(target)
+    const {
+      operation = "Removing files",
+      ...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"}`)
+
+      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)
+      }
+
+      const remainingItems = remaining.files.length > 0 ? remaining.files : remaining.paths
+
+      throw new PathRemovalBlockedError({
+        target: resolvedTarget,
+        operation,
+        remaining: remainingItems,
+        blockers: inspection.blockers,
+      }, error)
+    }
+  }
+}
+
+const removePath = createPathRemover()
+
+module.exports = {
+  PATH_REMOVAL_BLOCKED_CODE,
+  collectRemaining,
+  createPathRemover,
+  isPathRemovalBlockedError,
+  removePath,
+}

package/kernel/windows_restart_manager.js

@@ -0,0 +1,153 @@
+const path = require("path")
+
+const ERROR_SUCCESS = 0
+const ERROR_MORE_DATA = 234
+const CCH_RM_SESSION_KEY = 32
+
+let bindings = null
+
+const initialize = () => {
+  if (bindings) {
+    return bindings
+  }
+  if (process.platform !== "win32") {
+    return null
+  }
+
+  const koffi = require("koffi")
+  const library = koffi.load("rstrtmgr.dll")
+  const kernel32 = koffi.load("kernel32.dll")
+  const fileTime = koffi.struct("PINOKIO_RM_FILETIME", {
+    dwLowDateTime: "uint32_t",
+    dwHighDateTime: "uint32_t",
+  })
+  const uniqueProcess = koffi.struct("PINOKIO_RM_UNIQUE_PROCESS", {
+    dwProcessId: "uint32_t",
+    ProcessStartTime: fileTime,
+  })
+  const processInfo = koffi.struct("PINOKIO_RM_PROCESS_INFO", {
+    Process: uniqueProcess,
+    strAppName: koffi.array("char16_t", 256, "String"),
+    strServiceShortName: koffi.array("char16_t", 64, "String"),
+    ApplicationType: "int32_t",
+    AppStatus: "uint32_t",
+    TSSessionId: "uint32_t",
+    bRestartable: "int32_t",
+  })
+
+  bindings = {
+    koffi,
+    processInfo,
+    startSession: library.func("uint32_t __stdcall RmStartSession(_Out_ uint32_t *session, uint32_t flags, _Out_ void *sessionKey)"),
+    registerResources: library.func("uint32_t __stdcall RmRegisterResources(uint32_t session, uint32_t fileCount, const str16 *files, uint32_t applicationCount, const void *applications, uint32_t serviceCount, const str16 *services)"),
+    getList: library.func("uint32_t __stdcall RmGetList(uint32_t session, _Out_ uint32_t *needed, _Inout_ uint32_t *count, _Out_ void *processes, _Out_ uint32_t *rebootReasons)"),
+    endSession: library.func("uint32_t __stdcall RmEndSession(uint32_t session)"),
+    openProcess: kernel32.func("void * __stdcall OpenProcess(uint32_t access, int32_t inheritHandle, uint32_t processId)"),
+    queryFullProcessImageName: kernel32.func("int32_t __stdcall QueryFullProcessImageNameW(void *process, uint32_t flags, _Out_ void *filename, _Inout_ uint32_t *size)"),
+    closeHandle: kernel32.func("int32_t __stdcall CloseHandle(void *handle)"),
+  }
+  return bindings
+}
+
+const queryProcessImage = (api, pid) => {
+  const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+  const handle = api.openProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid)
+  if (!handle) {
+    return ""
+  }
+  try {
+    const capacity = 32768
+    const buffer = Buffer.alloc(capacity * 2)
+    const size = [capacity]
+    if (!api.queryFullProcessImageName(handle, 0, buffer, size)) {
+      return ""
+    }
+    return String(api.koffi.decode.string16(buffer) || "")
+  } catch (_) {
+    return ""
+  } finally {
+    api.closeHandle(handle)
+  }
+}
+
+const normalizeProcessInfo = (entry) => {
+  const uniqueProcess = entry && entry.Process ? entry.Process : {}
+  const pid = Number(uniqueProcess.dwProcessId) || 0
+  return {
+    pid,
+    name: String(entry && entry.strAppName ? entry.strAppName : "").trim(),
+    serviceName: String(entry && entry.strServiceShortName ? entry.strServiceShortName : "").trim(),
+  }
+}
+
+const inspectWindowsFileLocks = async (files) => {
+  if (process.platform !== "win32") {
+    return { blockers: [] }
+  }
+
+  const resources = Array.from(new Set((Array.isArray(files) ? files : [])
+    .filter((file) => typeof file === "string" && file.length > 0)))
+  if (resources.length === 0) {
+    return { blockers: [] }
+  }
+
+  const api = initialize()
+  const session = [0]
+  const sessionKey = Buffer.alloc((CCH_RM_SESSION_KEY + 1) * 2)
+  let status = api.startSession(session, 0, sessionKey)
+  if (status !== ERROR_SUCCESS) {
+    throw new Error(`RmStartSession failed with Windows error ${status}`)
+  }
+
+  try {
+    status = api.registerResources(session[0], resources.length, resources, 0, null, 0, null)
+    if (status !== ERROR_SUCCESS) {
+      throw new Error(`RmRegisterResources failed with Windows error ${status}`)
+    }
+
+    let needed = [0]
+    let count = [0]
+    let rebootReasons = [0]
+    status = api.getList(session[0], needed, count, null, rebootReasons)
+    if (status === ERROR_SUCCESS && needed[0] === 0) {
+      return { blockers: [] }
+    }
+    if (status !== ERROR_MORE_DATA && status !== ERROR_SUCCESS) {
+      throw new Error(`RmGetList failed with Windows error ${status}`)
+    }
+
+    let capacity = Math.max(needed[0], 1)
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      count = [capacity]
+      needed = [capacity]
+      rebootReasons = [0]
+      const buffer = Buffer.alloc(api.koffi.sizeof(api.processInfo) * capacity)
+      status = api.getList(session[0], needed, count, buffer, rebootReasons)
+      if (status === ERROR_SUCCESS) {
+        const entries = api.koffi.decode(buffer, api.processInfo, Math.min(count[0], capacity))
+        const blockers = entries
+          .map(normalizeProcessInfo)
+          .filter((entry) => entry.pid > 0)
+          .map((entry) => {
+            const imagePath = queryProcessImage(api, entry.pid)
+            return {
+              ...entry,
+              executable: imagePath ? path.win32.basename(imagePath) : "",
+            }
+          })
+        return { blockers }
+      }
+      if (status !== ERROR_MORE_DATA) {
+        throw new Error(`RmGetList failed with Windows error ${status}`)
+      }
+      capacity = Math.max(needed[0], capacity + 1)
+    }
+    throw new Error("RmGetList changed repeatedly while enumerating blocking processes")
+  } finally {
+    api.endSession(session[0])
+  }
+}
+
+module.exports = {
+  inspectWindowsFileLocks,
+}

package/package.json

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

package/server/index.js

@@ -34,6 +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 git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -16263,14 +16264,38 @@ class Server {
     }))
     this.app.post("/pinokio/delete", ex(async (req, res) => {
       try {
-        if (req.body.type === 'bin') {
+        if (req.body.type === 'conda-runtime') {
+          for (const runtimeName of ["miniconda", "miniforge"]) {
+            const runtimePath = this.kernel.path("bin", runtimeName)
+            await removePath(runtimePath, {
+              recursive: true,
+              force: true,
+              maxRetries: 5,
+              retryDelay: 250,
+              operation: "Updating Miniforge",
+            })
+          }
+          res.json({ success: true })
+        } else if (req.body.type === 'bin') {
           let folderPath = this.kernel.path("bin")
-          await fse.remove(folderPath)
+          await removePath(folderPath, {
+            recursive: true,
+            force: true,
+            maxRetries: 5,
+            retryDelay: 250,
+            operation: "Resetting managed tools",
+          })
           await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
           res.json({ success: true })
         } else if (req.body.type === 'cache') {
           let folderPath = this.kernel.path("cache")
-          await fse.remove(folderPath)
+          await removePath(folderPath, {
+            recursive: true,
+            force: true,
+            maxRetries: 5,
+            retryDelay: 250,
+            operation: "Clearing the Pinokio cache",
+          })
           await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
           await Environment.ensurePinokioCacheDirs(this.kernel, {
             throwOnFailure: true
@@ -16288,7 +16313,13 @@ class Server {
           res.json({ success: true })
         } else if (req.body.name) {
           let folderPath = this.kernel.path("api", req.body.name)
-          await fse.remove(folderPath)
+          await removePath(folderPath, {
+            recursive: true,
+            force: true,
+            maxRetries: 5,
+            retryDelay: 250,
+            operation: `Deleting ${req.body.name}`,
+          })
 //          await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
           await new Promise((resolve, reject) => {
             setTimeout(() => {
@@ -16299,6 +16330,10 @@ class Server {
           res.json({ success: true })
         }
       } catch(err) {
+        if (isPathRemovalBlockedError(err)) {
+          res.status(423).json({ success: false, error: err.toJSON() })
+          return
+        }
         res.json({ error: err.stack })
       }
     }))

package/server/public/common.js

@@ -1,4 +1,194 @@
 const CAPTURE_MIN_SIZE = 32;
+
+const PinokioPathRemoval = (() => {
+  const BLOCKED_CODE = "PINOKIO_PATH_REMOVE_BLOCKED"
+  const RETRY_INTERVAL = 2000
+
+  const escapeHtml = (value) => String(value == null ? "" : value)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;")
+
+  const blockedDetails = (payload) => {
+    if (!payload || typeof payload !== "object") {
+      return null
+    }
+    if (payload.code === BLOCKED_CODE) {
+      return payload
+    }
+    if (payload.error && payload.error.code === BLOCKED_CODE) {
+      return payload.error
+    }
+    return null
+  }
+
+  const renderBlocker = (blocker) => {
+    const name = blocker.name || blocker.serviceName || `Process ${blocker.pid || ""}`
+    const detail = [
+      blocker.executable && blocker.executable !== name ? blocker.executable : "",
+      blocker.serviceName && blocker.serviceName !== name ? blocker.serviceName : "",
+      blocker.pid ? `PID ${blocker.pid}` : "",
+    ].filter(Boolean).join(" · ")
+    return `<li class="pinokio-path-blocker-item">
+      <span class="pinokio-path-blocker-name">${escapeHtml(name)}</span>
+      ${detail ? `<span class="pinokio-path-blocker-detail">${escapeHtml(detail)}</span>` : ""}
+    </li>`
+  }
+
+  const render = (details) => {
+    const blockers = Array.isArray(details.blockers) ? details.blockers : []
+    const remaining = Array.isArray(details.remaining) ? details.remaining : []
+    const itemCount = Number(details.remainingCount) || remaining.length
+    const itemLabel = itemCount === 1 ? "one remaining item" : `${itemCount || "some"} remaining items`
+    const causeCode = details.causeCode ? ` (${escapeHtml(details.causeCode)})` : ""
+    const explanation = blockers.length > 0
+      ? `Windows couldn't remove ${itemLabel} because ${itemCount === 1 ? "it is" : "they are"} still in use.`
+      : `Windows couldn't remove ${itemLabel}${causeCode}. No application was identified. Check permissions or security software.`
+    const blockerHtml = blockers.length > 0
+      ? `<ul class="pinokio-path-blocker-list">${blockers.map(renderBlocker).join("")}</ul>`
+      : ""
+    const filesHtml = remaining.length > 0
+      ? `<details class="pinokio-path-blocker-files">
+          <summary>${itemCount > remaining.length ? `Show first ${remaining.length} of ${itemCount} remaining items` : `Show remaining ${remaining.length === 1 ? "item" : "items"}`}</summary>
+          <div>${remaining.map((file) => `<code>${escapeHtml(file)}</code>`).join("")}</div>
+        </details>`
+      : ""
+    return `<div class="pinokio-path-blocker">
+      <p>${explanation}</p>
+      ${blockerHtml}
+      ${filesHtml}
+      <div class="pinokio-path-blocker-wait">
+        <i class="fa-solid fa-circle-notch fa-spin" aria-hidden="true"></i>
+        <span>${blockers.length > 0
+          ? `Close the ${blockers.length === 1 ? "app" : "apps"} above. Pinokio will retry automatically.`
+          : "Resolve the access issue. Pinokio will retry automatically."}</span>
+      </div>
+    </div>`
+  }
+
+  const parseResponse = async (response) => {
+    if (!response || typeof response.json !== "function") {
+      return response
+    }
+    const fallbackResponse = typeof response.clone === "function" ? response.clone() : null
+    let payload
+    try {
+      payload = await response.json()
+    } catch (_) {
+      const text = fallbackResponse && typeof fallbackResponse.text === "function"
+        ? await fallbackResponse.text()
+        : ""
+      throw new Error(text || `Request failed (${response.status || "unknown"})`)
+    }
+    if (!response.ok && !blockedDetails(payload)) {
+      const message = payload && payload.error
+      throw new Error(typeof message === "string" ? message : `Request failed (${response.status})`)
+    }
+    return payload
+  }
+
+  const show = async ({ details, retry }) => {
+    if (typeof Swal === "undefined" || !Swal || typeof Swal.fire !== "function") {
+      return { cancelled: true }
+    }
+
+    let current = details
+    let retrying = false
+    let settled = false
+    let timer = null
+
+    return await new Promise((resolve) => {
+      const finish = (result) => {
+        if (settled) return
+        settled = true
+        if (timer) clearInterval(timer)
+        if (Swal.isVisible()) Swal.close()
+        resolve(result)
+      }
+
+      const update = () => {
+        const container = Swal.getHtmlContainer()
+        if (container) container.innerHTML = render(current)
+      }
+
+      const attempt = async (manual = false) => {
+        if (retrying || settled || typeof retry !== "function") return false
+        retrying = true
+        if (typeof Swal.disableButtons === "function") Swal.disableButtons()
+        try {
+          const result = await retry()
+          const nextBlocked = blockedDetails(result)
+          if (nextBlocked) {
+            current = nextBlocked
+            update()
+            if (manual) Swal.showValidationMessage("Windows still cannot remove the remaining items.")
+            return false
+          }
+          finish(result)
+          return true
+        } catch (error) {
+          if (manual) Swal.showValidationMessage(escapeHtml(error && error.message ? error.message : "Retry failed."))
+          return false
+        } finally {
+          retrying = false
+          if (!settled && typeof Swal.enableButtons === "function") Swal.enableButtons()
+        }
+      }
+
+      Swal.fire({
+        title: escapeHtml(current.operation || "File removal paused"),
+        html: render(current),
+        showCancelButton: true,
+        confirmButtonText: "Try again now",
+        cancelButtonText: "Stop for now",
+        allowOutsideClick: false,
+        allowEscapeKey: false,
+        didOpen: () => {
+          timer = setInterval(() => attempt(false), RETRY_INTERVAL)
+        },
+        preConfirm: async () => {
+          const done = await attempt(true)
+          return done ? true : false
+        },
+        willClose: () => {
+          if (timer) clearInterval(timer)
+        },
+      }).then((result) => {
+        if (!settled && !result.isConfirmed) {
+          finish({ cancelled: true })
+        }
+      })
+    })
+  }
+
+  const request = async (requestFactory) => {
+    const execute = async () => parseResponse(await requestFactory())
+    const initial = await execute()
+    const details = blockedDetails(initial)
+    if (!details) {
+      return initial
+    }
+    if (typeof Swal !== "undefined" && Swal && Swal.isVisible()) {
+      Swal.close()
+    }
+    return show({
+      details,
+      retry: execute,
+    })
+  }
+
+  return {
+    blockedDetails,
+    request,
+    show,
+  }
+})()
+
+if (typeof window !== "undefined") {
+  window.PinokioPathRemoval = PinokioPathRemoval
+}
 let pinokioDevGuardSatisfied = false;
 const createLauncherDebugLog = (...args) => {
   try {