pinokiod 7.2.10 → 7.2.11

package/kernel/environment.js

@@ -5,136 +5,165 @@ 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")
-  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
-  } catch (error) {
-    await fs.promises.rm(testDir, { recursive: true, force: true }).catch(() => {})
-    return false
+  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 ensureWritableDirectory = async (dirPath, options = {}) => {
-  if (!dirPath) {
-    return false
+const managedCacheEnvDefaults = () => {
+  const defaults = {}
+  for (const key of CACHE_PREFLIGHT_KEYS) {
+    defaults[key] = `./cache/${key}`
   }
-  const repair = !!options.repair
+  return defaults
+}
+
+const ensureCachePreflightDir = async (key, targetPath) => {
+  logCachePreflight(`${key}: target=${targetPath}`)
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true })
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: mkdir ok`)
   } catch (error) {
-    if (!repair) {
-      return false
-    }
-    await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
-    try {
-      await fs.promises.mkdir(dirPath, { recursive: true })
-    } catch (mkdirError) {
-      return false
-    }
-  }
-  if (await canWriteDirectory(dirPath)) {
-    return true
+    logCachePreflight(`${key}: mkdir failed ${formatCachePreflightError(error)}`)
   }
-  if (!repair) {
-    return false
+
+  const firstProbe = await probeCacheDir(targetPath)
+  if (firstProbe.ok) {
+    logCachePreflight(`${key}: probe ok`)
+    return { key, path: targetPath, repaired: false, ok: true }
   }
-  await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+
+  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) {
-    return false
+    logCachePreflight(`${key}: repair delete failed ${formatCachePreflightError(error)}`)
+    return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", 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)
-}
+  try {
+    await fs.promises.mkdir(targetPath, { recursive: true })
+    logCachePreflight(`${key}: repair mkdir ok`)
+  } catch (error) {
+    logCachePreflight(`${key}: repair mkdir failed ${formatCachePreflightError(error)}`)
+    return { key, path: targetPath, repaired: true, ok: false, step: "repair mkdir", error }
+  }
 
-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)
+    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/package.json

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