npm - pinokiod - Versions diffs - 8.0.8 → 8.0.9 - Mend

pinokiod 8.0.8 → 8.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/kernel/bin/conda.js +17 -17
package/kernel/path_removal.js +133 -0
package/kernel/windows_restart_manager.js +153 -0
package/package.json +1 -1
package/server/index.js +39 -4
package/server/public/common.js +190 -0
package/server/public/style.css +65 -0
package/server/views/app.ejs +2 -4
package/server/views/download.ejs +5 -5
package/server/views/editor.ejs +5 -5
package/server/views/env_editor.ejs +4 -2
package/server/views/file_explorer.ejs +2 -4
package/server/views/index.ejs +2 -4
package/server/views/install.ejs +25 -0
package/server/views/net.ejs +2 -4
package/server/views/settings.ejs +10 -10
package/server/views/setup.ejs +5 -5
package/server/views/terminal.ejs +5 -5
package/test/conda-bin.test.js +11 -11
package/test/fixtures/hold-windows-dll.js +21 -0
package/test/path-removal-ui.test.js +316 -0
package/test/path-removal.test.js +189 -0
package/test/windows-path-removal.integration.test.js +78 -0

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

@@ -0,0 +1,316 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const { JSDOM, VirtualConsole } = require("jsdom")
+const repoRoot = path.resolve(__dirname, "..")
+const commonScriptPath = path.join(repoRoot, "server/public/common.js")
+async function waitFor(predicate, message = "condition") {
+  const deadline = Date.now() + 1000
+  while (Date.now() < deadline) {
+    if (predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 5))
+  }
+  assert.fail(`Timed out waiting for ${message}`)
+}
+function response(payload, { ok = false, status = 423 } = {}) {
+  return {
+    ok,
+    status,
+    json: async () => payload,
+  }
+}
+async function createHarness() {
+  const source = await fs.readFile(commonScriptPath, "utf8")
+  const state = {
+    buttonsDisabled: false,
+    clearedIntervals: new Set(),
+    closeCount: 0,
+    fireOptions: null,
+    htmlContainer: null,
+    intervals: new Map(),
+    nextIntervalId: 1,
+    resolveFire: null,
+    validationMessage: "",
+    visible: false,
+  }
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on("jsdomError", (error) => {
+    throw error
+  })
+  const dom = new JSDOM("<!doctype html><body></body>", {
+    runScripts: "dangerously",
+    url: "http://localhost/",
+    virtualConsole,
+    beforeParse(window) {
+      window.fetch = async () => response({}, { ok: true, status: 200 })
+      window.matchMedia = () => ({
+        matches: false,
+        addEventListener() {},
+        removeEventListener() {},
+      })
+      window.ResizeObserver = class {
+        observe() {}
+        disconnect() {}
+      }
+      window.setInterval = (callback, delay) => {
+        const id = state.nextIntervalId++
+        state.intervals.set(id, { callback, delay })
+        return id
+      }
+      window.clearInterval = (id) => {
+        state.clearedIntervals.add(id)
+        state.intervals.delete(id)
+      }
+      window.Swal = {
+        disableButtons() {
+          state.buttonsDisabled = true
+        },
+        enableButtons() {
+          state.buttonsDisabled = false
+        },
+        close() {
+          if (!state.visible) return
+          state.closeCount += 1
+          state.visible = false
+          if (state.fireOptions && typeof state.fireOptions.willClose === "function") {
+            state.fireOptions.willClose()
+          }
+          if (state.resolveFire) state.resolveFire({ isConfirmed: false })
+        },
+        fire(options) {
+          state.fireOptions = options
+          state.htmlContainer = window.document.createElement("div")
+          state.htmlContainer.innerHTML = options.html || ""
+          window.document.body.appendChild(state.htmlContainer)
+          state.visible = true
+          if (typeof options.didOpen === "function") options.didOpen()
+          return new Promise((resolve) => {
+            state.resolveFire = resolve
+          })
+        },
+        getHtmlContainer() {
+          return state.htmlContainer
+        },
+        isVisible() {
+          return state.visible
+        },
+        showValidationMessage(message) {
+          state.validationMessage = message
+        },
+      }
+    },
+  })
+  const script = dom.window.document.createElement("script")
+  script.textContent = source
+  dom.window.document.body.appendChild(script)
+  state.dismiss = () => {
+    if (!state.visible || state.buttonsDisabled) return false
+    state.visible = false
+    if (state.fireOptions && typeof state.fireOptions.willClose === "function") {
+      state.fireOptions.willClose()
+    }
+    state.resolveFire({ isConfirmed: false })
+    return true
+  }
+  state.getRetryIntervalId = () => Array.from(state.intervals.entries())
+    .filter(([, interval]) => interval.delay === 2000)
+    .map(([id]) => id)
+    .pop()
+  state.runInterval = async () => {
+    const interval = state.intervals.get(state.getRetryIntervalId())
+    assert.ok(interval, "expected an active retry interval")
+    return await interval.callback()
+  }
+  return { dom, state, api: dom.window.PinokioPathRemoval }
+}
+test("path-removal modal renders identified blockers and escapes backend text", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+  const shown = api.show({
+    details: {
+      operation: "Delete <app>",
+      blockers: [{
+        name: "G <HUB>",
+        executable: "C:\\Program Files\\G & HUB\\lghub.exe",
+        pid: 4321,
+      }],
+      remainingCount: 25,
+      remaining: Array.from({ length: 20 }, (_, index) => `C:\\runtime\\file-${index}.dll`),
+    },
+    retry: async () => ({ ok: true }),
+  })
+  assert.equal(state.fireOptions.title, "Delete &lt;app&gt;")
+  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, /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)
+  const intervalId = state.getRetryIntervalId()
+  state.dismiss()
+  const result = await shown
+  assert.equal(result.cancelled, true)
+  assert.equal(state.intervals.has(intervalId), false)
+})
+test("path-removal modal reports unattributed EACCES without naming an application", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+  const shown = api.show({
+    details: {
+      operation: "Delete app",
+      causeCode: "EACCES",
+      blockers: [],
+      remainingCount: 1,
+      remaining: ["C:\\runtime\\protected.dll"],
+    },
+    retry: async () => ({ ok: true }),
+  })
+  assert.match(state.htmlContainer.textContent, /Windows couldn't remove one remaining item \(EACCES\)/)
+  assert.match(state.htmlContainer.textContent, /Check permissions or security software/)
+  assert.match(state.htmlContainer.textContent, /Resolve the access issue/)
+  assert.doesNotMatch(state.htmlContainer.textContent, /Close the app above/)
+  state.dismiss()
+  assert.equal((await shown).cancelled, true)
+})
+test("path-removal request retries automatically without overlapping and resolves on success", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+  let requestCount = 0
+  let resolveRetry
+  const retryResponse = new Promise((resolve) => {
+    resolveRetry = resolve
+  })
+  const resultPromise = api.request(async () => {
+    requestCount += 1
+    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"],
+        },
+      })
+    }
+    if (requestCount === 2) return await retryResponse
+    return response({ ok: true }, { ok: true, status: 200 })
+  })
+  await waitFor(() => state.fireOptions, "path-removal modal")
+  const intervalId = state.getRetryIntervalId()
+  assert.equal(state.intervals.get(intervalId).delay, 2000)
+  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.visible, true)
+  await state.runInterval()
+  assert.equal(requestCount, 2, "a pending retry must suppress overlapping retries")
+  resolveRetry(response({
+    success: false,
+    error: {
+      code: "PINOKIO_PATH_REMOVE_BLOCKED",
+      operation: "Replace Miniforge",
+      blockers: [{ name: "Second blocker", pid: 20 }],
+      remainingCount: 1,
+      remaining: ["C:\\runtime\\second.dll"],
+    },
+  }))
+  await firstAttempt
+  assert.equal(state.buttonsDisabled, false)
+  assert.match(state.htmlContainer.textContent, /Second blocker/)
+  assert.doesNotMatch(state.htmlContainer.textContent, /First blocker/)
+  await state.runInterval()
+  const result = await resultPromise
+  assert.equal(result.ok, true)
+  assert.equal(requestCount, 3)
+  assert.equal(state.closeCount, 1)
+  assert.equal(state.intervals.has(intervalId), false)
+  assert.ok(state.clearedIntervals.has(intervalId))
+})
+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())
+  let retryCount = 0
+  const shown = api.show({
+    details: {
+      operation: "Delete app",
+      blockers: [{ name: "Lock holder", pid: 99 }],
+      remainingCount: 1,
+      remaining: ["C:\\app\\locked.dll"],
+    },
+    retry: async () => {
+      retryCount += 1
+      return {
+        code: "PINOKIO_PATH_REMOVE_BLOCKED",
+        operation: "Delete app",
+        blockers: [{ name: "Lock holder", pid: 99 }],
+        remainingCount: 1,
+        remaining: ["C:\\app\\locked.dll"],
+      }
+    },
+  })
+  assert.equal(await state.fireOptions.preConfirm(), false)
+  assert.equal(retryCount, 1)
+  assert.equal(state.visible, true)
+  assert.equal(state.validationMessage, "Windows still cannot remove the remaining items.")
+  assert.equal(state.buttonsDisabled, false)
+  const intervalId = state.getRetryIntervalId()
+  state.dismiss()
+  const result = await shown
+  assert.equal(result.cancelled, true)
+  assert.equal(state.intervals.has(intervalId), false)
+  assert.ok(state.clearedIntervals.has(intervalId))
+})
+test("manual retry escapes unexpected error messages", async (t) => {
+  const { api, dom, state } = await createHarness()
+  t.after(() => dom.window.close())
+  const shown = api.show({
+    details: {
+      operation: "Delete app",
+      blockers: [],
+      remainingCount: 1,
+      remaining: ["C:\\app\\locked.dll"],
+    },
+    retry: async () => {
+      throw new Error('<img src=x onerror="window.compromised=true">')
+    },
+  })
+  assert.equal(await state.fireOptions.preConfirm(), false)
+  assert.equal(state.validationMessage, "&lt;img src=x onerror=&quot;window.compromised=true&quot;&gt;")
+  assert.equal(state.buttonsDisabled, false)
+  state.dismiss()
+  assert.equal((await shown).cancelled, true)
+})

package/test/path-removal.test.js ADDED Viewed

@@ -0,0 +1,189 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const {
+  PATH_REMOVAL_BLOCKED_CODE,
+  collectRemaining,
+  createPathRemover,
+} = require("../kernel/path_removal")
+test("removePath preserves ordinary fs.rm behavior", async () => {
+  const calls = []
+  const removePath = createPathRemover({
+    platform: "darwin",
+    fsPromises: {
+      rm: async (target, options) => calls.push({ target, options }),
+    },
+  })
+  const target = path.resolve(os.tmpdir(), "pinokio-remove-success")
+  const result = await removePath(target, {
+    recursive: true,
+    force: true,
+    operation: "Deleting test data",
+  })
+  assert.deepEqual(result, { removed: true, target })
+  assert.deepEqual(calls, [{ target, options: { recursive: true, force: true } }])
+})
+test("removePath rethrows lock-shaped errors outside Windows", async () => {
+  const original = Object.assign(new Error("busy"), { code: "EPERM" })
+  const removePath = createPathRemover({
+    platform: "darwin",
+    fsPromises: {
+      rm: async () => { throw original },
+    },
+  })
+  await assert.rejects(
+    removePath("/tmp/pinokio-remove-busy", { recursive: true }),
+    (error) => error === original,
+  )
+})
+test("removePath reports Windows blockers after partial recursive deletion and succeeds on retry", async () => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-remove-blocked-"))
+  const lockedDir = path.join(root, "pkgs", "git", "Library", "bin")
+  const lockedFile = path.join(lockedDir, "zlib1.dll")
+  const removableFile = path.join(root, "already-removed.txt")
+  await fs.promises.mkdir(lockedDir, { recursive: true })
+  await fs.promises.writeFile(lockedFile, "locked")
+  await fs.promises.writeFile(removableFile, "remove me")
+  let locked = true
+  const inspected = []
+  const fsPromises = {
+    lstat: fs.promises.lstat.bind(fs.promises),
+    readdir: fs.promises.readdir.bind(fs.promises),
+    rm: async (target, options) => {
+      if (!locked) {
+        return fs.promises.rm(target, options)
+      }
+      await fs.promises.rm(removableFile, { force: true })
+      throw Object.assign(new Error("operation not permitted"), { code: "EPERM" })
+    },
+  }
+  const removePath = createPathRemover({
+    platform: "win32",
+    fsPromises,
+    inspectLocks: async (files) => {
+      inspected.push(files)
+      return {
+        blockers: [{ pid: 8544, name: "Logitech G HUB" }],
+      }
+    },
+  })
+  await assert.rejects(
+    removePath(root, {
+      recursive: true,
+      force: true,
+      operation: "Updating Miniforge",
+    }),
+    (error) => {
+      assert.equal(error.code, PATH_REMOVAL_BLOCKED_CODE)
+      assert.equal(error.operation, "Updating Miniforge")
+      assert.equal(error.causeCode, "EPERM")
+      assert.deepEqual(error.remaining, [lockedFile])
+      assert.equal(error.remainingCount, 1)
+      assert.equal(error.blockers[0].pid, 8544)
+      assert.equal(error.toJSON().code, PATH_REMOVAL_BLOCKED_CODE)
+      return true
+    },
+  )
+  assert.equal(await fs.promises.access(removableFile).then(() => true).catch(() => false), false)
+  assert.deepEqual(inspected, [[lockedFile]])
+  locked = false
+  const result = await removePath(root, { recursive: true, force: true })
+  assert.equal(result.removed, true)
+  assert.equal(await fs.promises.access(root).then(() => true).catch(() => false), 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 }))
+  const remainingFile = path.join(root, "denied.txt")
+  await fs.promises.writeFile(remainingFile, "denied")
+  const removePath = createPathRemover({
+    platform: "win32",
+    fsPromises: {
+      lstat: fs.promises.lstat.bind(fs.promises),
+      readdir: fs.promises.readdir.bind(fs.promises),
+      rm: async () => { throw Object.assign(new Error("access denied"), { code: "EACCES" }) },
+    },
+    inspectLocks: async () => { throw new Error("diagnostic failed") },
+  })
+  const originalWarn = console.warn
+  let warning
+  console.warn = (...args) => { warning = args }
+  try {
+    await assert.rejects(
+      removePath(root, { recursive: true, force: true }),
+      (error) => {
+        assert.equal(error.code, PATH_REMOVAL_BLOCKED_CODE)
+        assert.equal(error.causeCode, "EACCES")
+        assert.deepEqual(error.blockers, [])
+        assert.doesNotMatch(error.message, /still in use/)
+        return true
+      },
+    )
+  } finally {
+    console.warn = originalWarn
+  }
+  assert.equal(warning[0], "[path removal] Restart Manager inspection failed")
+  assert.match(warning[1].message, /diagnostic failed/)
+})
+test("removePath inspects every remaining file but limits the serialized preview", async (t) => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-remove-preview-"))
+  t.after(() => fs.promises.rm(root, { recursive: true, force: true }))
+  const files = Array.from({ length: 25 }, (_, index) => path.join(root, `${index}.txt`))
+  await Promise.all(files.map((file) => fs.promises.writeFile(file, "remaining")))
+  let inspected = []
+  const removePath = createPathRemover({
+    platform: "win32",
+    fsPromises: {
+      lstat: fs.promises.lstat.bind(fs.promises),
+      readdir: fs.promises.readdir.bind(fs.promises),
+      rm: async () => { throw Object.assign(new Error("busy"), { code: "EBUSY" }) },
+    },
+    inspectLocks: async (remaining) => {
+      inspected = remaining
+      return { blockers: [] }
+    },
+  })
+  await assert.rejects(removePath(root, { recursive: true, force: true }), (error) => {
+    assert.equal(error.remainingCount, 25)
+    assert.equal(error.remaining.length, 20)
+    assert.equal(error.toJSON().remaining.length, 20)
+    return true
+  })
+  assert.equal(inspected.length, 25)
+})
+test("remaining-file discovery does not traverse symbolic links", async (t) => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-remove-links-"))
+  const outside = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-remove-outside-"))
+  const outsideFile = path.join(outside, "outside.txt")
+  const link = path.join(root, "linked")
+  await fs.promises.writeFile(outsideFile, "outside")
+  await fs.promises.symlink(outside, link, process.platform === "win32" ? "junction" : "dir")
+  t.after(async () => {
+    await fs.promises.rm(root, { recursive: true, force: true })
+    await fs.promises.rm(outside, { recursive: true, force: true })
+  })
+  const remaining = await collectRemaining(root)
+  assert.equal(remaining.files.includes(link), true)
+  assert.equal(remaining.paths.includes(outsideFile), false)
+})

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

@@ -0,0 +1,78 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { spawn } = require("child_process")
+const { PATH_REMOVAL_BLOCKED_CODE, removePath } = require("../kernel/path_removal")
+const waitForExit = (child) => {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve()
+  }
+  return new Promise((resolve) => child.once("exit", resolve))
+}
+const waitForReady = (child) => new Promise((resolve, reject) => {
+  let output = ""
+  const timer = setTimeout(() => reject(new Error("DLL holder did not become ready")), 10000)
+  child.stdout.on("data", (chunk) => {
+    output += chunk.toString()
+    if (output.includes("READY")) {
+      clearTimeout(timer)
+      resolve()
+    }
+  })
+  child.once("exit", (code) => {
+    clearTimeout(timer)
+    reject(new Error(`DLL holder exited before ready (${code})`))
+  })
+})
+test("Windows integration: loaded DLL is diagnosed and removable after release", {
+  skip: process.platform !== "win32",
+  timeout: 30000,
+}, async (t) => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-windows-lock-"))
+  const dllPath = path.join(root, "version.dll")
+  const ordinaryFile = path.join(root, "ordinary.txt")
+  await fs.promises.copyFile(path.join(process.env.SystemRoot, "System32", "version.dll"), dllPath)
+  await fs.promises.writeFile(ordinaryFile, "ordinary")
+  const child = spawn(process.execPath, [path.join(__dirname, "fixtures", "hold-windows-dll.js"), dllPath], {
+    stdio: ["pipe", "pipe", "pipe"],
+  })
+  t.after(async () => {
+    if (child.exitCode === null && child.signalCode === null) {
+      const exited = waitForExit(child)
+      child.kill()
+      await exited
+    }
+    await fs.promises.rm(root, { recursive: true, force: true }).catch(() => {})
+  })
+  await waitForReady(child)
+  await assert.rejects(
+    removePath(root, {
+      recursive: true,
+      force: true,
+      maxRetries: 1,
+      retryDelay: 50,
+      operation: "Windows integration test",
+    }),
+    (error) => {
+      assert.equal(error.code, PATH_REMOVAL_BLOCKED_CODE)
+      assert.equal(error.remaining.includes(dllPath), true)
+      assert.equal(error.blockers.some((blocker) => blocker.pid === child.pid), true)
+      return true
+    },
+  )
+  assert.equal(await fs.promises.access(ordinaryFile).then(() => true).catch(() => false), false)
+  const exited = new Promise((resolve) => child.once("exit", resolve))
+  child.stdin.write("release\n")
+  await exited
+  await removePath(root, { recursive: true, force: true })
+  assert.equal(await fs.promises.access(root).then(() => true).catch(() => false), false)
+})