pinokiod 7.2.10 → 7.2.12

package/kernel/environment.js

@@ -5,136 +5,184 @@ const fs = require('fs')
 const Util = require('./util')
 const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
 const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
+const CACHE_PREFLIGHT_KEYS = TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)
 
-const envKey = (env, key) => {
-  return Object.keys(env).find((candidate) => candidate.toLowerCase() === key.toLowerCase())
-}
-
-const setEnv = (env, key, value) => {
-  for (const candidate of Object.keys(env)) {
-    if (candidate.toLowerCase() === key.toLowerCase() && candidate !== key) {
-      delete env[candidate]
-    }
+const formatCachePreflightError = (error) => {
+  if (!error) {
+    return ""
   }
-  env[key] = value
-}
-
-const normalizeEnvPath = (value, root) => {
-  if (typeof value !== "string") {
-    return null
+  const parts = []
+  if (error.code) {
+    parts.push(`code=${error.code}`)
+  }
+  if (typeof error.errno !== "undefined") {
+    parts.push(`errno=${error.errno}`)
   }
-  const trimmed = value.trim()
-  if (!trimmed) {
-    return null
+  if (error.syscall) {
+    parts.push(`syscall=${error.syscall}`)
   }
-  if (path.isAbsolute(trimmed)) {
-    return path.resolve(trimmed)
+  if (error.path) {
+    parts.push(`path=${error.path}`)
   }
-  if (trimmed.startsWith("./") || trimmed.startsWith(".\\")) {
-    return path.resolve(root, trimmed)
+  if (error.dest) {
+    parts.push(`dest=${error.dest}`)
   }
-  return path.resolve(root, trimmed)
+  if (error.message) {
+    parts.push(`message=${error.message}`)
+  }
+  return parts.join(" ")
 }
 
-const isInsidePath = (candidate, root) => {
-  const rel = path.relative(path.resolve(root), path.resolve(candidate))
-  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel))
+const logCachePreflight = (message) => {
+  console.log(`[Pinokio cache preflight] ${message}`)
 }
 
-const canWriteDirectory = async (dirPath) => {
-  if (!dirPath) {
-    return false
-  }
-  const testDir = path.resolve(
+const probeCacheDir = async (dirPath) => {
+  const probeDir = path.resolve(
     dirPath,
-    `.pinokio-write-test-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+    `.pinokio-cache-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
   )
-  const testFile = path.resolve(testDir, "probe.tmp")
-  const renamedFile = path.resolve(testDir, "probe-renamed.tmp")
+  const probeFile = path.resolve(probeDir, "probe.tmp")
+  const renamedFile = path.resolve(probeDir, "probe-renamed.tmp")
+  const steps = [
+    ["create probe directory", () => fs.promises.mkdir(probeDir, { recursive: false })],
+    ["write probe file", () => fs.promises.writeFile(probeFile, "pinokio")],
+    ["append probe file", () => fs.promises.appendFile(probeFile, "-cache-probe")],
+    ["rename probe file", () => fs.promises.rename(probeFile, renamedFile)],
+    ["delete probe file", () => fs.promises.unlink(renamedFile)],
+    ["remove probe directory", () => fs.promises.rmdir(probeDir)]
+  ]
+
+  for (const [step, run] of steps) {
+    try {
+      await run()
+    } catch (error) {
+      await fs.promises.rm(probeDir, { recursive: true, force: true }).catch(() => {})
+      return { ok: false, step, error }
+    }
+  }
+  return { ok: true }
+}
+
+const managedCacheEnvDefaults = () => {
+  const defaults = {}
+  for (const key of CACHE_PREFLIGHT_KEYS) {
+    defaults[key] = `./cache/${key}`
+  }
+  return defaults
+}
+
+const ensureCachePreflightDir = async (key, targetPath, options = {}) => {
+  logCachePreflight(`${key}: target=${targetPath}`)
   try {
-    await fs.promises.mkdir(testDir, { recursive: true })
-    await fs.promises.writeFile(testFile, "pinokio")
-    await fs.promises.appendFile(testFile, "-probe")
-    await fs.promises.rename(testFile, renamedFile)
-    await fs.promises.unlink(renamedFile)
-    await fs.promises.rmdir(testDir)
-    return true
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: mkdir ok`)
   } catch (error) {
-    await fs.promises.rm(testDir, { recursive: true, force: true }).catch(() => {})
-    return false
+    logCachePreflight(`${key}: mkdir failed ${formatCachePreflightError(error)}`)
   }
-}
 
-const ensureWritableDirectory = async (dirPath, options = {}) => {
-  if (!dirPath) {
-    return false
+  const firstProbe = await probeCacheDir(targetPath)
+  if (firstProbe.ok) {
+    logCachePreflight(`${key}: probe ok`)
+    return { key, path: targetPath, repaired: false, ok: true }
   }
-  const repair = !!options.repair
+
+  logCachePreflight(`${key}: probe failed step="${firstProbe.step}" ${formatCachePreflightError(firstProbe.error)}`)
+  logCachePreflight(`${key}: repair delete start path=${targetPath}`)
+
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true })
+    await fs.promises.rm(targetPath, { recursive: true, force: true })
+    logCachePreflight(`${key}: repair delete ok`)
   } catch (error) {
-    if (!repair) {
-      return false
+    logCachePreflight(`${key}: repair delete failed ${formatCachePreflightError(error)}`)
+    if (typeof options.elevatedRepair !== "function") {
+      return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", error }
     }
-    await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+    logCachePreflight(`${key}: elevated repair start path=${targetPath}`)
+    let elevatedRepair
     try {
-      await fs.promises.mkdir(dirPath, { recursive: true })
-    } catch (mkdirError) {
-      return false
+      elevatedRepair = await options.elevatedRepair(targetPath, logCachePreflight)
+    } catch (repairError) {
+      elevatedRepair = { ok: false, error: repairError }
     }
+    if (!elevatedRepair || !elevatedRepair.ok) {
+      return { key, path: targetPath, repaired: false, elevated: true, ok: false, step: "elevated repair", error: elevatedRepair && elevatedRepair.error ? elevatedRepair.error : error }
+    }
+    const elevatedProbe = await probeCacheDir(targetPath)
+    if (elevatedProbe.ok) {
+      logCachePreflight(`${key}: elevated repair probe ok`)
+      return { key, path: targetPath, repaired: true, elevated: true, ok: true }
+    }
+    logCachePreflight(`${key}: elevated repair probe failed step="${elevatedProbe.step}" ${formatCachePreflightError(elevatedProbe.error)}`)
+    return { key, path: targetPath, repaired: true, elevated: true, ok: false, step: elevatedProbe.step, error: elevatedProbe.error }
   }
-  if (await canWriteDirectory(dirPath)) {
-    return true
-  }
-  if (!repair) {
-    return false
-  }
-  await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true })
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: repair mkdir ok`)
   } catch (error) {
-    return false
+    logCachePreflight(`${key}: repair mkdir failed ${formatCachePreflightError(error)}`)
+    return { key, path: targetPath, repaired: true, ok: false, step: "repair mkdir", error }
   }
-  return canWriteDirectory(dirPath)
-}
 
-const canRepairManagedCachePath = (candidate, cacheRoot) => {
-  const rel = path.relative(path.resolve(cacheRoot), path.resolve(candidate))
-  return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel)
-}
-
-const managedCacheEnvDefaults = () => {
-  const defaults = {}
-  for (const key of TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)) {
-    defaults[key] = `./cache/${key}`
+  const secondProbe = await probeCacheDir(targetPath)
+  if (secondProbe.ok) {
+    logCachePreflight(`${key}: repair probe ok`)
+    return { key, path: targetPath, repaired: true, ok: true }
   }
-  return defaults
+
+  logCachePreflight(`${key}: repair probe failed step="${secondProbe.step}" ${formatCachePreflightError(secondProbe.error)}`)
+  return { key, path: targetPath, repaired: true, ok: false, step: secondProbe.step, error: secondProbe.error }
 }
 
-const ensurePinokioCacheDirs = async (kernel) => {
+const ensurePinokioCacheDirs = async (kernel, options = {}) => {
   if (!kernel || !kernel.homedir) {
     return {}
   }
+  const throwOnFailure = !!options.throwOnFailure
   const root = path.resolve(kernel.homedir)
   const cacheRoot = path.resolve(root, "cache")
   const envPath = path.resolve(root, "ENVIRONMENT")
   const defaults = managedCacheEnvDefaults()
+  logCachePreflight(`start root=${root}`)
   await Util.update_env(envPath, defaults)
-  const env = await get(root, kernel)
+  logCachePreflight(`ENVIRONMENT updated keys=${CACHE_PREFLIGHT_KEYS.join(",")}`)
+  try {
+    await fs.promises.mkdir(cacheRoot, { recursive: true })
+    logCachePreflight(`cache root mkdir ok path=${cacheRoot}`)
+  } catch (error) {
+    logCachePreflight(`cache root mkdir failed path=${cacheRoot} ${formatCachePreflightError(error)}`)
+  }
+
+  const errors = []
+  const results = []
 
-  for (const key of TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)) {
-    const existingKey = envKey(env, key)
-    const dirPath = normalizeEnvPath(existingKey ? env[existingKey] : defaults[key], root)
-    const managedPath = path.resolve(cacheRoot, key)
-    const targetPath = dirPath && isInsidePath(dirPath, root) ? dirPath : managedPath
-    const repair = canRepairManagedCachePath(targetPath, cacheRoot)
-    if (!repair || !(await ensureWritableDirectory(targetPath, { repair: true }))) {
-      throw new Error(`Pinokio could not create a writable ${key} directory: ${targetPath}`)
+  for (const key of CACHE_PREFLIGHT_KEYS) {
+    const targetPath = path.resolve(cacheRoot, key)
+    const result = await ensureCachePreflightDir(key, targetPath, options)
+    results.push(result)
+    if (!result.ok) {
+      errors.push(result)
     }
-    setEnv(env, key, targetPath)
   }
 
-  return env
+  if (errors.length > 0) {
+    kernel.cacheDirErrors = errors
+    const message = errors
+      .map((error) => `${error.key}: ${error.path} (${error.step || "unknown"} ${formatCachePreflightError(error.error)})`)
+      .join(", ")
+    logCachePreflight(`failed ${message}`)
+    if (throwOnFailure) {
+      throw new Error(`Pinokio could not create writable cache directories: ${message}`)
+    }
+  } else {
+    kernel.cacheDirErrors = []
+    logCachePreflight(`complete ok checked=${results.length} repaired=${results.filter((result) => result.repaired).length}`)
+  }
+
+  kernel.cacheDirPreflight = results
+  const env = await get(root, kernel)
+  return { env, errors, results }
 }
 const ENVS = async () => {
 //  const primary_port = 80

package/kernel/index.js

@@ -44,6 +44,7 @@ const WatchManager = require('./watch')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
+const sudo = process.platform === "win32" ? require("sudo-prompt-programfiles-x86") : null
 //const kill = require('./tree-kill');
 const kill = require('kill-sync')
 const ejs = require('ejs');
@@ -55,6 +56,34 @@ const VARS = {
   }
 }
 
+const powershellSingleQuote = (value) => {
+  return `'${String(value).replace(/'/g, "''")}'`
+}
+
+const windowsCacheRepairCommand = (targetPath) => {
+  const psPath = powershellSingleQuote(targetPath)
+  return [
+    "powershell.exe",
+    "-NoProfile",
+    "-ExecutionPolicy Bypass",
+    "-Command",
+    `"`,
+    "$ErrorActionPreference = 'Stop';",
+    `$p = ${psPath};`,
+    "$account = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name;",
+    "$grant = $account + ':(OI)(CI)F';",
+    "if (Test-Path -LiteralPath $p) {",
+    "  & takeown.exe /F $p /R /D Y;",
+    "  & icacls.exe $p /reset /T /C;",
+    "  & icacls.exe $p /grant $grant /T /C;",
+    "  Remove-Item -LiteralPath $p -Recurse -Force;",
+    "}",
+    "New-Item -ItemType Directory -Force -Path $p | Out-Null;",
+    "& icacls.exe $p /grant $grant /T /C;",
+    `"`
+  ].join(" ")
+}
+
 //const memwatch = require('@airbnb/node-memwatch');
 class Kernel {
   schema = "<=7.0.0"
@@ -465,6 +494,30 @@ class Kernel {
       return ''
     }
   }
+  async elevatedCacheRepair(targetPath, log = console.log) {
+    if (this.platform !== "win32" || !sudo) {
+      return { ok: false, error: new Error("Elevated cache repair is only available on Windows") }
+    }
+    const command = windowsCacheRepairCommand(targetPath)
+    log(`elevated repair command=${command}`)
+    return new Promise((resolve) => {
+      sudo.exec(command, { name: "Pinokio" }, (error, stdout, stderr) => {
+        if (stdout && stdout.trim()) {
+          log(`elevated repair stdout ${stdout.trim()}`)
+        }
+        if (stderr && stderr.trim()) {
+          log(`elevated repair stderr ${stderr.trim()}`)
+        }
+        if (error) {
+          log(`elevated repair failed ${error.message || error}`)
+          resolve({ ok: false, error, stdout, stderr })
+        } else {
+          log(`elevated repair ok path=${targetPath}`)
+          resolve({ ok: true, stdout, stderr })
+        }
+      })
+    })
+  }
   async ensureRouterMode() {
     const domain = await this.resolvePinokioDomain()
     const shouldUseCustom = domain.length > 0
@@ -1053,7 +1106,10 @@ class Kernel {
 
         // 2. mkdir all the folders if not already created
         await Environment.init_folders(this.homedir, this)
-        await Environment.ensurePinokioCacheDirs(this)
+        await Environment.ensurePinokioCacheDirs(this, {
+          throwOnFailure: true,
+          elevatedRepair: this.elevatedCacheRepair.bind(this)
+        })
 
         // if key.json doesn't exist, create an empty json file
         let ee = await this.exists(this.homedir, "key.json")

package/package.json

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

package/server/index.js

@@ -5707,6 +5707,16 @@ class Server {
 
         needsManagedRefresh = true
         console.log("[TRY] Updating to the new version")
+        let envPath = path.resolve(home, "ENVIRONMENT")
+        let envExists = await this.kernel.exists(envPath)
+        if (!envExists) {
+          let str = await Environment.ENV("system", home, this.kernel)
+          await fs.promises.writeFile(envPath, str)
+        }
+        await Environment.ensurePinokioCacheDirs(this.kernel, {
+          throwOnFailure: true,
+          elevatedRepair: this.kernel.elevatedCacheRepair.bind(this.kernel)
+        })
         this.kernel.store.set("version", this.version.pinokiod)
         console.log("[DONE] Updating to the new version")
         console.log("not up to date. update py.")