pinokiod 8.0.17 → 8.0.19

package/kernel/bin/conda.js

@@ -254,27 +254,7 @@ report_errors: false`)
   }
   async removeInstallPath(target, ondata) {
     try {
-      const stat = await fs.promises.lstat(target).catch((error) => {
-        if (error && error.code === "ENOENT") {
-          return null
-        }
-        throw error
-      })
-      if (!stat) {
-        return
-      }
-      if (stat.isSymbolicLink()) {
-        await removePath(target, {
-          force: true,
-          operation: "Updating Miniforge",
-        })
-        return
-      }
-      await removePath(target, {
-        recursive: true,
-        force: true,
-        operation: "Updating Miniforge",
-      })
+      await removePath(target)
     } catch (error) {
       if (isPathRemovalBlockedError(error)) {
         if (typeof ondata === "function") {

package/kernel/bin/index.js

@@ -715,22 +715,7 @@ class Bin {
     let res = await Util.filepicker(req, ondata, this.kernel)
     return res
   }
-  async runInstallExclusive(task) {
-    const previous = this.installQueue || Promise.resolve()
-    let release
-    const current = new Promise((resolve) => { release = resolve })
-    this.installQueue = previous.then(() => current)
-    await previous
-    try {
-      return await task()
-    } finally {
-      release()
-    }
-  }
   async install(req, ondata) {
-    return await this.runInstallExclusive(() => this.installRequirements(req, ondata))
-  }
-  async installRequirements(req, ondata) {
     /*
       req.params := {
         client: {

package/kernel/path_removal.js

@@ -3,7 +3,6 @@ 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 {
@@ -16,21 +15,17 @@ class PathRemovalBlockedError extends Error {
     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,
@@ -39,21 +34,25 @@ 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 isInside = (target, candidate) => {
+  const relative = path.relative(target, candidate)
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative))
 }
 
-const isPathRemovalBlockedError = (error) => !!(error && error.code === PATH_REMOVAL_BLOCKED_CODE)
-const isPathRemovalPendingError = (error) => !!(error && error.code === PATH_REMOVAL_PENDING_CODE)
+const pathExists = async (target, fsPromises) => {
+  try {
+    await fsPromises.lstat(target)
+    return true
+  } catch (error) {
+    return !error || error.code !== "ENOENT"
+  }
+}
 
 const collectRemaining = async (target, fsPromises = fs.promises) => {
-  const files = []
-  const paths = []
+  const remaining = []
+  const regularFiles = []
   const pending = [path.resolve(target)]
 
   while (pending.length > 0) {
@@ -65,28 +64,40 @@ const collectRemaining = async (target, fsPromises = fs.promises) => {
       if (error && error.code === "ENOENT") {
         continue
       }
-      paths.push(current)
+      remaining.push(current)
       continue
     }
 
-    paths.push(current)
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-      files.push(current)
+    if (!stat.isDirectory()) {
+      remaining.push(current)
+      if (stat.isFile()) {
+        regularFiles.push(current)
+      }
       continue
     }
 
     let entries
     try {
-      entries = await fsPromises.readdir(current, { withFileTypes: true })
-    } catch (_) {
+      entries = await fsPromises.readdir(current)
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        remaining.push(current)
+      }
+      continue
+    }
+    if (entries.length === 0) {
+      remaining.push(current)
       continue
     }
     for (const entry of entries) {
-      pending.push(path.resolve(current, entry.name))
+      const child = path.resolve(current, entry)
+      if (isInside(target, child)) {
+        pending.push(child)
+      }
     }
   }
 
-  return { files, paths }
+  return { remaining, regularFiles }
 }
 
 const createPathRemover = (dependencies = {}) => {
@@ -94,44 +105,36 @@ const createPathRemover = (dependencies = {}) => {
   const platform = dependencies.platform || process.platform
   const inspectLocks = dependencies.inspectLocks || inspectWindowsFileLocks
 
-  return async (target, options = {}) => {
+  return async (target) => {
     const resolvedTarget = path.resolve(target)
-    const {
-      operation = "Removing files",
-      diagnose = true,
-      ...rmOptions
-    } = options
 
     try {
-      await fsPromises.rm(resolvedTarget, rmOptions)
-      return { removed: true, target: resolvedTarget }
+      await fsPromises.rm(resolvedTarget, { recursive: true, force: true })
     } catch (error) {
       if (platform !== "win32") {
         throw error
       }
-      if (!diagnose) {
-        throw new PathRemovalPendingError(resolvedTarget, error)
-      }
 
-      const remaining = await collectRemaining(resolvedTarget, fsPromises)
-      if (remaining.paths.length === 0) {
-        throw error
+      if (!(await pathExists(resolvedTarget, fsPromises))) {
+        return
+      }
+      const diagnosis = await collectRemaining(resolvedTarget, fsPromises)
+      if (!(await pathExists(resolvedTarget, fsPromises))) {
+        return
       }
 
-      let inspection = { blockers: [] }
-      try {
-        inspection = await inspectLocks(remaining.files)
-      } catch (inspectionError) {
-        console.warn("[path removal] Restart Manager inspection failed", inspectionError)
+      let blockers = []
+      if (diagnosis.regularFiles.length > 0) {
+        blockers = await inspectLocks(diagnosis.regularFiles).catch(() => [])
+        if (!Array.isArray(blockers)) blockers = []
       }
 
-      const remainingItems = remaining.files.length > 0 ? remaining.files : remaining.paths
+      const remaining = diagnosis.remaining.length > 0 ? diagnosis.remaining : [resolvedTarget]
 
       throw new PathRemovalBlockedError({
         target: resolvedTarget,
-        operation,
-        remaining: remainingItems,
-        blockers: inspection.blockers,
+        remaining,
+        blockers,
       }, error)
     }
   }
@@ -141,10 +144,8 @@ const removePath = createPathRemover()
 
 module.exports = {
   PATH_REMOVAL_BLOCKED_CODE,
-  PATH_REMOVAL_PENDING_CODE,
-  collectRemaining,
+  PathRemovalBlockedError,
   createPathRemover,
   isPathRemovalBlockedError,
-  isPathRemovalPendingError,
   removePath,
 }

package/kernel/windows_restart_manager.js

@@ -1,5 +1,3 @@
-const path = require("path")
-
 const ERROR_SUCCESS = 0
 const ERROR_MORE_DATA = 234
 const CCH_RM_SESSION_KEY = 32
@@ -16,7 +14,6 @@ const initialize = () => {
 
   const koffi = require("koffi")
   const library = koffi.load("rstrtmgr.dll")
-  const kernel32 = koffi.load("kernel32.dll")
   const fileTime = koffi.struct({
     dwLowDateTime: "uint32_t",
     dwHighDateTime: "uint32_t",
@@ -42,34 +39,10 @@ const initialize = () => {
     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
@@ -82,13 +55,13 @@ const normalizeProcessInfo = (entry) => {
 
 const inspectWindowsFileLocks = async (files) => {
   if (process.platform !== "win32") {
-    return { blockers: [] }
+    return []
   }
 
   const resources = Array.from(new Set((Array.isArray(files) ? files : [])
     .filter((file) => typeof file === "string" && file.length > 0)))
   if (resources.length === 0) {
-    return { blockers: [] }
+    return []
   }
 
   const api = initialize()
@@ -110,7 +83,7 @@ const inspectWindowsFileLocks = async (files) => {
     let rebootReasons = [0]
     status = api.getList(session[0], needed, count, null, rebootReasons)
     if (status === ERROR_SUCCESS && needed[0] === 0) {
-      return { blockers: [] }
+      return []
     }
     if (status !== ERROR_MORE_DATA && status !== ERROR_SUCCESS) {
       throw new Error(`RmGetList failed with Windows error ${status}`)
@@ -128,14 +101,7 @@ const inspectWindowsFileLocks = async (files) => {
         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 }
+        return blockers
       }
       if (status !== ERROR_MORE_DATA) {
         throw new Error(`RmGetList failed with Windows error ${status}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.17",
+  "version": "8.0.19",
   "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, isPathRemovalPendingError, removePath } = require("../kernel/path_removal")
+const { isPathRemovalBlockedError, removePath } = require("../kernel/path_removal")
 
 const git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -63,40 +63,6 @@ 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
-}
-
 
 
 
@@ -16297,50 +16263,24 @@ 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') {
-          await this.kernel.bin.runInstallExclusive(async () => {
-            for (const runtimeName of ["miniconda", "miniforge"]) {
-              const runtimePath = this.kernel.path("bin", runtimeName)
-              await removePath(runtimePath, {
-                recursive: true,
-                force: true,
-                diagnose: req.body.background !== true,
-                operation: "Updating Miniforge",
-              })
-            }
-          })
+          for (const runtimeName of ["miniconda", "miniforge"]) {
+            const runtimePath = this.kernel.path("bin", runtimeName)
+            await removePath(runtimePath)
+          }
           res.json({ success: true })
         } else if (req.body.type === 'bin') {
           let folderPath = this.kernel.path("bin")
-          await this.kernel.bin.runInstallExclusive(async () => {
-            const removalStartedAt = Date.now()
-            console.log(`[fresh install] removing bin: start ${folderPath}`)
-            await removePath(folderPath, {
-              recursive: true,
-              force: true,
-              diagnose: req.body.background !== true,
-              operation: "Resetting managed tools",
-            })
-            console.log(`[fresh install] removing bin: complete (${((Date.now() - removalStartedAt) / 1000).toFixed(1)}s)`)
-            await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
-            const refreshStartedAt = Date.now()
-            await this.kernel.bin.refreshInstalled()
-            console.log(`[fresh install] refreshing installed state: complete (${((Date.now() - refreshStartedAt) / 1000).toFixed(1)}s)`)
-          })
+          const removalStartedAt = Date.now()
+          console.log(`[fresh install] removing bin: start ${folderPath}`)
+          await removePath(folderPath)
+          console.log(`[fresh install] removing bin: complete (${((Date.now() - removalStartedAt) / 1000).toFixed(1)}s)`)
+          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 removePath(folderPath, {
-            recursive: true,
-            force: true,
-            diagnose: req.body.background !== true,
-            operation: "Clearing the Pinokio cache",
-          })
+          await removePath(folderPath)
           await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
           await Environment.ensurePinokioCacheDirs(this.kernel, {
             throwOnFailure: true
@@ -16357,17 +16297,8 @@ class Server {
           }
           res.json({ success: true })
         } else if (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}`,
-          })
+          let folderPath = this.kernel.path("api", req.body.name)
+          await removePath(folderPath)
 //          await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
           await new Promise((resolve, reject) => {
             setTimeout(() => {
@@ -16378,10 +16309,6 @@ 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

@@ -27,7 +27,6 @@ const PinokioPathRemoval = (() => {
   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(" · ")
@@ -44,7 +43,7 @@ const PinokioPathRemoval = (() => {
     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} because one or more files 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>`
@@ -69,27 +68,15 @@ const PinokioPathRemoval = (() => {
   }
 
   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) && !(payload && payload.pending === true)) {
+    const payload = await response.json()
+    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 }) => {
+  const show = ({ details, retry }) => {
     if (typeof Swal === "undefined" || !Swal || typeof Swal.fire !== "function") {
       return { cancelled: true }
     }
@@ -99,7 +86,7 @@ const PinokioPathRemoval = (() => {
     let settled = false
     let timer = null
 
-    return await new Promise((resolve) => {
+    return new Promise((resolve) => {
       const finish = (result) => {
         if (settled) return
         settled = true
@@ -123,18 +110,20 @@ const PinokioPathRemoval = (() => {
         retrying = true
         if (manual && typeof Swal.disableButtons === "function") Swal.disableButtons()
         try {
-          const result = await retry(manual)
+          const result = await retry()
           if (settled) return false
-          if (result && result.pending === true) {
-            return false
-          }
           const nextBlocked = blockedDetails(result)
           if (nextBlocked) {
-            current = nextBlocked
-            update()
-            if (manual) Swal.showValidationMessage("Windows still cannot remove the remaining items.")
+            if (manual) {
+              current = nextBlocked
+              update()
+              Swal.showValidationMessage("Windows still cannot remove the remaining items.")
+            }
             return false
           }
+          if (result && result.error) {
+            throw new Error(typeof result.error === "string" ? result.error : "Retry failed.")
+          }
           finish(result)
           return true
         } catch (error) {
@@ -147,7 +136,7 @@ const PinokioPathRemoval = (() => {
       }
 
       Swal.fire({
-        title: escapeHtml(current.operation || "File removal paused"),
+        title: "File removal paused",
         html: render(current),
         showCancelButton: true,
         confirmButtonText: "Try again now",
@@ -157,13 +146,7 @@ const PinokioPathRemoval = (() => {
         didOpen: () => {
           timer = setInterval(() => attempt(false), RETRY_INTERVAL)
         },
-        preConfirm: async () => {
-          const done = await attempt(true)
-          return done ? true : false
-        },
-        willClose: () => {
-          if (timer) clearInterval(timer)
-        },
+        preConfirm: () => attempt(true),
       }).then((result) => {
         if (!settled && !result.isConfirmed) {
           finish({ cancelled: true })
@@ -172,9 +155,14 @@ const PinokioPathRemoval = (() => {
     })
   }
 
-  const request = async (requestFactory) => {
-    const execute = async (background = false) => parseResponse(await requestFactory(background))
-    const initial = await execute()
+  const tryRemove = async (payload) => parseResponse(await fetch("/pinokio/delete", {
+    method: "post",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  }))
+
+  const remove = async (payload) => {
+    const initial = await tryRemove(payload)
     const details = blockedDetails(initial)
     if (!details) {
       return initial
@@ -184,14 +172,14 @@ const PinokioPathRemoval = (() => {
     }
     return show({
       details,
-      retry: (manual) => execute(!manual),
+      retry: () => tryRemove(payload),
     })
   }
 
   return {
-    blockedDetails,
-    request,
+    remove,
     show,
+    tryRemove,
   }
 })()
 

package/server/public/style.css

@@ -6985,10 +6985,6 @@ body.dark .swal2-popup.swal2-modal:not(.loader-popup):not(.pinokio-download-moda
 }
 
 .pinokio-path-blocker-item {
-  display: flex;
-  align-items: baseline;
-  justify-content: space-between;
-  gap: 16px;
   padding: 8px 0;
   border-bottom: 1px solid rgba(127, 127, 127, 0.18);
 }
@@ -6998,26 +6994,18 @@ body.dark .swal2-popup.swal2-modal:not(.loader-popup):not(.pinokio-download-moda
 }
 
 .pinokio-path-blocker-detail {
+  display: block;
   font-size: 12px;
   overflow-wrap: anywhere;
-  text-align: right;
 }
 
 .pinokio-path-blocker-files {
   margin: 0 0 14px;
 }
 
-.pinokio-path-blocker-files summary {
-  cursor: pointer;
-}
-
-.pinokio-path-blocker-files div {
-  display: grid;
-  gap: 6px;
-  margin-top: 8px;
-}
-
 .pinokio-path-blocker-files code {
+  display: block;
+  margin-top: 6px;
   overflow-wrap: anywhere;
   white-space: normal;
 }
@@ -7027,14 +7015,3 @@ body.dark .swal2-popup.swal2-modal:not(.loader-popup):not(.pinokio-download-moda
   align-items: center;
   gap: 8px;
 }
-
-@media (max-width: 560px) {
-  .pinokio-path-blocker-item {
-    display: grid;
-    gap: 2px;
-  }
-
-  .pinokio-path-blocker-detail {
-    text-align: left;
-  }
-}