pinokiod 7.2.9 → 7.2.10

package/kernel/environment.js

@@ -3,7 +3,139 @@ const portfinder = require('portfinder-cp')
 const os = require('os')
 const fs = require('fs')
 const Util = require('./util')
-const platform = os.platform()
+const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
+const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
+
+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]
+    }
+  }
+  env[key] = value
+}
+
+const normalizeEnvPath = (value, root) => {
+  if (typeof value !== "string") {
+    return null
+  }
+  const trimmed = value.trim()
+  if (!trimmed) {
+    return null
+  }
+  if (path.isAbsolute(trimmed)) {
+    return path.resolve(trimmed)
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith(".\\")) {
+    return path.resolve(root, trimmed)
+  }
+  return path.resolve(root, trimmed)
+}
+
+const isInsidePath = (candidate, root) => {
+  const rel = path.relative(path.resolve(root), path.resolve(candidate))
+  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel))
+}
+
+const canWriteDirectory = async (dirPath) => {
+  if (!dirPath) {
+    return false
+  }
+  const testDir = path.resolve(
+    dirPath,
+    `.pinokio-write-test-${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 ensureWritableDirectory = async (dirPath, options = {}) => {
+  if (!dirPath) {
+    return false
+  }
+  const repair = !!options.repair
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true })
+  } 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
+  }
+  if (!repair) {
+    return false
+  }
+  await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true })
+  } catch (error) {
+    return false
+  }
+  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}`
+  }
+  return defaults
+}
+
+const ensurePinokioCacheDirs = async (kernel) => {
+  if (!kernel || !kernel.homedir) {
+    return {}
+  }
+  const root = path.resolve(kernel.homedir)
+  const cacheRoot = path.resolve(root, "cache")
+  const envPath = path.resolve(root, "ENVIRONMENT")
+  const defaults = managedCacheEnvDefaults()
+  await Util.update_env(envPath, defaults)
+  const env = await get(root, kernel)
+
+  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}`)
+    }
+    setEnv(env, key, targetPath)
+  }
+
+  return env
+}
 const ENVS = async () => {
 //  const primary_port = 80
 //  const secondary_port = 42000
@@ -828,4 +960,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, requirements, init, get_root  }
+module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root  }

package/kernel/index.js

@@ -1053,6 +1053,7 @@ class Kernel {
 
         // 2. mkdir all the folders if not already created
         await Environment.init_folders(this.homedir, this)
+        await Environment.ensurePinokioCacheDirs(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.9",
+  "version": "7.2.10",
   "description": "",
   "main": "index.js",
   "scripts": {