pinokiod 7.2.17 → 7.3.0

package/Dockerfile

@@ -37,6 +37,8 @@ RUN mkdir -p /app/.pinokio-seed \
     && rm -rf /app/.pinokio-seed/network/system/.git \
     && rm -rf /app/.pinokio-seed/plugin \
     && mkdir -p /app/.pinokio-seed/plugin \
+    && git clone --depth 1 https://github.com/pinokiocomputer/code /app/.pinokio-seed/plugin/code \
+    && rm -rf /app/.pinokio-seed/plugin/code/.git \
     && rm -rf /app/.pinokio-seed/prototype/system \
     && mkdir -p /app/.pinokio-seed/prototype \
     && git clone --depth 1 https://github.com/pinokiocomputer/proto /app/.pinokio-seed/prototype/system \

package/kernel/api/index.js

@@ -11,7 +11,6 @@ const fastq = require('fastq')
 const Loader = require("../loader")
 const Environment = require("../environment")
 const Util = require('../util')
-const ShellRunTemplate = require('./shell_run_template')
 
 class Api {
   constructor(kernel) {
@@ -29,19 +28,6 @@ class Api {
     this.child_procs = {}
     this.lproxy = new Lproxy()
   }
-  startData(rpc) {
-    if (rpc && rpc.method === "process.wait" && rpc.params && typeof rpc.params === "object" && !Array.isArray(rpc.params)) {
-      let data = rpc
-      if (typeof data.title === "undefined" && typeof rpc.params.title !== "undefined") {
-        data = { ...data, title: rpc.params.title }
-      }
-      if (typeof data.description === "undefined" && typeof rpc.params.description !== "undefined") {
-        data = { ...data, description: rpc.params.description }
-      }
-      return data
-    }
-    return rpc
-  }
   async launcher_path(name) {
     let root_path = this.kernel.path("api", name)
     let primary_path = path.resolve(root_path, "pinokio.js")
@@ -430,12 +416,6 @@ class Api {
         await this.process(script.on.stop) 
       }
     }
-    if (this.kernel.watch && typeof this.kernel.watch.stop === "function") {
-      if (req.params.id) {
-        await this.kernel.watch.stop(req.params.id)
-      }
-      await this.kernel.watch.stop(requestPath)
-    }
     // reset modules
     let modpath = this.resolvePath(cwd, req.params.uri)
     if (this.child_procs[modpath]) {
@@ -1030,7 +1010,6 @@ class Api {
     }
     // replace {{{ }}} with {{ }}
     rpc = this.kernel.template.flatten(rpc)
-    rpc = ShellRunTemplate.renderEnvArgs(this.kernel, rpc, memory)
 
     // 6. rpc must have method names
     if (rpc.method) {
@@ -1199,7 +1178,7 @@ class Api {
           this.ondata({
             id: request.id || request.path,
             type: "start",
-            data: this.startData(rpc)
+            data: rpc
           })
 
           // DEPRECATED APIS
@@ -1475,25 +1454,6 @@ class Api {
     }
     return false
   }
-  async startWatchersForRequest(request, script, scriptDir, input) {
-    if (!this.kernel.watch || typeof this.kernel.watch.startForScript !== "function") {
-      return
-    }
-    const id = request.id || request.path
-    if (!id) {
-      return
-    }
-    const cwd = request.cwd || scriptDir
-    await this.kernel.watch.startForScript({
-      id,
-      request,
-      script,
-      cwd,
-      dirname: scriptDir,
-      input,
-      args: input
-    })
-  }
   createQueue(queue_id, concurrency) {
     this.queues[queue_id] = fastq.promise(async ({ request, rawrpc, input, step, total, cwd, args }) => {
       try {
@@ -1735,7 +1695,6 @@ class Api {
             }
 
             const initialPayload = typeof request.input === "undefined" ? {} : request.input
-            await this.startWatchersForRequest(request, script, cwd, initialPayload)
             this.queue(request, steps[0], initialPayload, 0, steps.length, cwd, initialPayload)
 
           } else {

package/kernel/api/process/index.js

@@ -34,16 +34,6 @@ class Process {
   constructor() {
     this.appApi = new AppAPI()
   }
-  async waitIndefinitely(req, kernel) {
-    await new Promise((resolve, reject) => {
-      this.resolve = resolve
-
-      // register the process with the root uri so it can be manually resolved (with this.resolve()) later
-      if (kernel && kernel.procs && req && req.parent && req.parent.path) {
-        kernel.procs[req.parent.path] = this
-      }
-    })
-  }
 //  async start(req, ondata, kernel) {
 //    /*
 //      req := {
@@ -169,8 +159,6 @@ class Process {
     /*
     params := {
       sec: <SECONDS>,
-      title: (optional) Title to display in the footer while waiting,
-      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -181,8 +169,6 @@ class Process {
 
     params := {
       min: <MINUTES>,
-      title: (optional) Title to display in the footer while waiting,
-      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -194,8 +180,6 @@ class Process {
     params := {
       url: <URL>,
       interval: (optional) how often to retry checking (in seconds)
-      title: (optional) Title to display in the footer while waiting,
-      description: (optional) Description to display in the footer while waiting,
       message: (optional) the message to display while retrying (default: no message)
     }
 
@@ -214,21 +198,9 @@ class Process {
 
     or
 
-    params := {
-      title: (optional) Title to display in the footer while waiting,
-      description: (optional) Description to display in the footer while waiting,
-    }
-
-    This waits indefinitely until the script is stopped or the wait is manually
-    resolved.
-
-    or
-
 
     params := {
       on: <wait-on condition https://github.com/jeffbski/wait-on>,
-      title: (optional) Title to display in the footer while waiting,
-      description: (optional) Description to display in the footer while waiting,
       message: (optional) Description to display while waiting,
       menu: (optional) menu to display in the modal while waiting,
 //      ok: (optional) <ok button text> (if not specified, no ok button),
@@ -240,84 +212,57 @@ class Process {
     if 'cancel' is pressed before the condition is met, stops the script
 
     */
-    let ms
-    const waitPath = req && req.parent && req.parent.path
-    if (waitPath && kernel) {
-      if (!kernel.activeProcessWaits) {
-        kernel.activeProcessWaits = {}
+    let ms 
+    if (req.params) {
+      if (req.params.app || req.params.id || req.params.name) {
+        await this.appApi.waitForAppPresence(req, ondata, kernel)
+        return
       }
-      kernel.activeProcessWaits[waitPath] = {
-        path: waitPath,
-        params: req.params || {},
-        title: req.params && req.params.title,
-        description: req.params && req.params.description,
-        message: req.params && req.params.message,
-        started: Date.now()
-      }
-    }
-    const showFooter = req.params && (req.params.title || req.params.description)
-    if (showFooter && typeof ondata === "function") {
-      ondata(req.params, "process.wait.start")
-    }
-    try {
-      if (req.params) {
-        if (req.params.app || req.params.id || req.params.name) {
-          await this.appApi.waitForAppPresence(req, ondata, kernel)
-          return
+      // Display modal
+      if (req.params.sec || req.params.min) {
+        // Wait
+        if (req.params.sec) {
+          ms = req.params.sec * 1000
+        } else if (req.params.min) {
+          ms = req.params.min * 60 * 1000
         }
-        // Display modal
-        if (req.params.sec || req.params.min) {
-          // Wait
-          if (req.params.sec) {
-            ms = req.params.sec * 1000
-          } else if (req.params.min) {
-            ms = req.params.min * 60 * 1000
-          }
-          await new Promise((resolve, reject) => {
-            this.resolve = resolve
+        await new Promise((resolve, reject) => {
+          this.resolve = resolve
 
-            // register the process with the root uri so it can be manually resolved (with this.resolve()) later
-            kernel.procs[req.parent.path] = this
+          // register the process with the root uri so it can be manually resolved (with this.resolve()) later
+          kernel.procs[req.parent.path] = this
 
-            setTimeout(() => {
-              this.resolve()
-            }, ms)
+          setTimeout(() => {
+            this.resolve()
+          }, ms)
+        })
+      } else if (req.params.uri) {
+        let interval = req.params.interval ? req.params.interval * 1000 : 1000
+        ondata(req.params, "loading.start")
+        await waitForUrl(req.params.uri, req.params.message, interval, ondata)
+        ondata(req.params, "loading.end")
+      } else if (req.params.url) {
+        let interval = req.params.interval ? req.params.interval * 1000 : 1000
+        ondata(req.params, "loading.start")
+        await waitForUrl(req.params.url, req.params.message, interval, ondata)
+        ondata(req.params, "loading.end")
+      } else if (req.params.on) {
+        // Wait
+        if (req.params.message) {
+          ondata({
+            raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
           })
-        } else if (req.params.uri) {
-          let interval = req.params.interval ? req.params.interval * 1000 : 1000
-          ondata(req.params, "loading.start")
-          await waitForUrl(req.params.uri, req.params.message, interval, ondata)
-          ondata(req.params, "loading.end")
-        } else if (req.params.url) {
-          let interval = req.params.interval ? req.params.interval * 1000 : 1000
-          ondata(req.params, "loading.start")
-          await waitForUrl(req.params.url, req.params.message, interval, ondata)
-          ondata(req.params, "loading.end")
-        } else if (req.params.on) {
-          // Wait
-          if (req.params.message) {
-            ondata({
-              raw: `\r\nWaiting: ${JSON.stringify(req.params.on)}\r\n`
-            })
-            ondata(req.params, "wait")
-          }
-          console.log("Wait", req.params.on)
-          await waitOn(req.params.on)
-          console.log("Wait finished")
-          ondata(req.params, "wait.end")
-        } else {
-          await this.waitIndefinitely(req, kernel)
+          ondata(req.params, "wait")
         }
-      } else {
-        await this.waitIndefinitely(req, kernel)
-      }
-    } finally {
-      if (waitPath && kernel && kernel.activeProcessWaits) {
-        delete kernel.activeProcessWaits[waitPath]
-      }
-      if (showFooter && typeof ondata === "function") {
-        ondata(req.params, "process.wait.end")
+        console.log("Wait", req.params.on)
+        await waitOn(req.params.on)
+        console.log("Wait finished")
+        ondata(req.params, "wait.end")
       }
+    } else {
+      await new Promise((resolve, reject) => {
+        this.resolve = resolve
+      })
     }
   }
 }

package/kernel/bin/conda-python.js

@@ -0,0 +1,30 @@
+const semver = require('semver')
+
+const WINDOWS_PYTHON_SSL_FIX_SPEC = "python=3.10.20=*_1_cpython"
+const WINDOWS_PYTHON_SSL_FIX_VERSION = "3.10.20"
+
+const condaBuildNumber = (build) => {
+  const chunks = String(build || "").split("_").reverse()
+  const buildNumber = chunks.find((chunk) => /^\d+$/.test(chunk))
+  return buildNumber ? Number(buildNumber) : null
+}
+
+const isWindowsPythonSslFixed = (version, build) => {
+  const coerced = semver.coerce(version)
+  if (!coerced) {
+    return false
+  }
+  if (!semver.satisfies(coerced, ">=3.10.20 <3.11.0")) {
+    return false
+  }
+  if (semver.eq(coerced, WINDOWS_PYTHON_SSL_FIX_VERSION)) {
+    const buildNumber = condaBuildNumber(build)
+    return typeof buildNumber === "number" && buildNumber >= 1
+  }
+  return true
+}
+
+module.exports = {
+  WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isWindowsPythonSslFixed,
+}

package/kernel/bin/conda.js

@@ -4,6 +4,11 @@ const fetch = require('cross-fetch')
 const { glob } = require('glob')
 const semver = require('semver')
 const { buildCondaListFromMeta } = require('./conda-meta')
+const {
+  WINDOWS_PYTHON_SSL_FIX_SPEC,
+  isWindowsPythonSslFixed,
+} = require('./conda-python')
+
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
   urls = {
@@ -160,6 +165,7 @@ report_errors: false`)
     let conda_check = {}
     let conda = new Set()
     let conda_versions = {}
+    let conda_builds = {}
     let start = false
     for(let line of lines) {
       if (start) {
@@ -167,8 +173,10 @@ report_errors: false`)
         if (chunks.length > 2) {
           let name = chunks[0]
           let version = chunks[1]
+          let build = chunks[2]
           conda.add(name)
           conda_versions[name] = version
+          conda_builds[name] = build
           if (name === "conda") {
             conda_check.conda = true
 //            //if (String(version) === "24.11.1") {
@@ -206,6 +214,9 @@ report_errors: false`)
             //  console.log("semver NOT satisfied")
             //}
           }
+          if (name === "python") {
+            conda_check.python = this.kernel.platform !== "win32" || isWindowsPythonSslFixed(version, build)
+          }
         }
       } else {
         if (/.*name.*version.*build.*channel/i.test(line)) {
@@ -215,7 +226,8 @@ report_errors: false`)
     }
     this.kernel.bin.installed.conda = conda
     this.kernel.bin.installed.conda_versions = conda_versions
-    return conda_check.conda && conda_check.mamba && conda_check.sqlite
+    this.kernel.bin.installed.conda_builds = conda_builds
+    return conda_check.conda && conda_check.mamba && conda_check.sqlite && (this.kernel.platform !== "win32" || conda_check.python)
     //return conda_check.conda && conda_check.mamba
   }
   async install(req, ondata) {
@@ -300,10 +312,18 @@ report_errors: false`)
     }).join(" ")
     console.log("Conda dependencies to install", { mods })
 
+    let condaPackages = [
+      `"sqlite=3.47.2"`,
+      `"conda-libmamba-solver>=25.4.0"`,
+    ]
+    if (this.kernel.platform === "win32") {
+      condaPackages.unshift(`"${WINDOWS_PYTHON_SSL_FIX_SPEC}"`)
+    }
+
     let cmds = [
       //"conda clean -y --index-cache",
       "conda clean -y --all",
-      `conda install -y -c conda-forge "sqlite=3.47.2" "conda-libmamba-solver>=25.4.0" ${mods}`,
+      `conda install -y -c conda-forge ${condaPackages.join(" ")} ${mods}`.trim(),
 
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_connect_timeout_secs 20`,
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_read_timeout_secs 300`,
@@ -339,7 +359,6 @@ report_errors: false`)
     //if (this.kernel.platform === "win32" || this.kernel.platform === "darwin") {
     //  cmds.push("conda install -y conda-libmamba-solver=24.7.0 conda=24.7.1 --freeze-installed")
     //}
-
     await this.kernel.bin.exec({
       message: cmds,
       env: {

package/kernel/bin/index.js

@@ -22,6 +22,7 @@ const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { buildCondaListFromMeta } = require('./conda-meta')
+const { isWindowsPythonSslFixed } = require('./conda-python')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
 const fse = require('fs-extra')
@@ -348,6 +349,8 @@ class Bin {
     let conda_check = {}
     let conda = new Set()
     let conda_versions = {}
+    let conda_builds = {}
+    this.correct_conda = false
 
     //////////////////////////////////////////////////////////////////
     // exception handling
@@ -386,8 +389,10 @@ class Bin {
           if (chunks.length > 2) {
             let name = chunks[0]
             let version = chunks[1]
+            let build = chunks[2]
             conda.add(name)
             conda_versions[name] = version
+            conda_builds[name] = build
             if (name === "conda") {
               conda_check.conda = true
             }
@@ -408,6 +413,9 @@ class Bin {
                 conda_check.sqlite = true
               }
             }
+            if (name === "python") {
+              conda_check.python = this.platform !== "win32" || isWindowsPythonSslFixed(version, build)
+            }
           }
         } else {
           if (/.*name.*version.*build.*channel/i.test(line)) {
@@ -416,13 +424,14 @@ class Bin {
         }
       }
 
-      if (conda_check.conda && conda_check.mamba && conda_check.sqlite) {
+      if (conda_check.conda && conda_check.mamba && conda_check.sqlite && (this.platform !== "win32" || conda_check.python)) {
       //if (conda_check.conda && conda_check.mamba) {
         this.correct_conda = true
       }
     }
     this.installed.conda = conda
     this.installed.conda_versions = conda_versions
+    this.installed.conda_builds = conda_builds
   }
   async refreshInstalled() {
 
@@ -430,6 +439,7 @@ class Bin {
 
     this.installed_initialized = false
     this.requirements_cache = {}
+    this.correct_conda = false
 
     //this.installed = {}
 

package/kernel/environment.js

@@ -3,187 +3,7 @@ const portfinder = require('portfinder-cp')
 const os = require('os')
 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 formatCachePreflightError = (error) => {
-  if (!error) {
-    return ""
-  }
-  const parts = []
-  if (error.code) {
-    parts.push(`code=${error.code}`)
-  }
-  if (typeof error.errno !== "undefined") {
-    parts.push(`errno=${error.errno}`)
-  }
-  if (error.syscall) {
-    parts.push(`syscall=${error.syscall}`)
-  }
-  if (error.path) {
-    parts.push(`path=${error.path}`)
-  }
-  if (error.dest) {
-    parts.push(`dest=${error.dest}`)
-  }
-  if (error.message) {
-    parts.push(`message=${error.message}`)
-  }
-  return parts.join(" ")
-}
-
-const logCachePreflight = (message) => {
-  console.log(`[Pinokio cache preflight] ${message}`)
-}
-
-const probeCacheDir = async (dirPath) => {
-  const probeDir = path.resolve(
-    dirPath,
-    `.pinokio-cache-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
-  )
-  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(targetPath, { recursive: true })
-    logCachePreflight(`${key}: mkdir ok`)
-  } catch (error) {
-    logCachePreflight(`${key}: mkdir failed ${formatCachePreflightError(error)}`)
-  }
-
-  const firstProbe = await probeCacheDir(targetPath)
-  if (firstProbe.ok) {
-    logCachePreflight(`${key}: probe ok`)
-    return { key, path: targetPath, repaired: false, ok: true }
-  }
-
-  logCachePreflight(`${key}: probe failed step="${firstProbe.step}" ${formatCachePreflightError(firstProbe.error)}`)
-  logCachePreflight(`${key}: repair delete start path=${targetPath}`)
-
-  try {
-    await fs.promises.rm(targetPath, { recursive: true, force: true })
-    logCachePreflight(`${key}: repair delete ok`)
-  } catch (error) {
-    logCachePreflight(`${key}: repair delete failed ${formatCachePreflightError(error)}`)
-    if (typeof options.elevatedRepair !== "function") {
-      return { key, path: targetPath, repaired: false, ok: false, step: "repair delete", error }
-    }
-    logCachePreflight(`${key}: elevated repair start path=${targetPath}`)
-    let elevatedRepair
-    try {
-      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 }
-  }
-
-  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 secondProbe = await probeCacheDir(targetPath)
-  if (secondProbe.ok) {
-    logCachePreflight(`${key}: repair probe ok`)
-    return { key, path: targetPath, repaired: true, ok: true }
-  }
-
-  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, 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)
-  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 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)
-    }
-  }
-
-  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 platform = os.platform()
 const ENVS = async () => {
 //  const primary_port = 80
 //  const secondary_port = 42000
@@ -1008,4 +828,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root  }
+module.exports = { ENV, get, get2, init_folders, requirements, init, get_root  }

package/kernel/git.js

@@ -1378,6 +1378,19 @@ class Git {
     const absoluteTarget = path.resolve(targetPath)
     const home = path.resolve(this.kernel.homedir)
     const managedTargets = [
+      {
+        kind: "plugin",
+        root: path.resolve(home, "plugin/code"),
+        matches: (root, target) => target === root || target.startsWith(`${root}${path.sep}`),
+        bootstrap: async () => {
+          await fs.promises.rm(path.resolve(home, "plugin/code"), { recursive: true, force: true })
+          this.dirs.delete(path.resolve(home, "plugin/code"))
+          if (this.kernel.plugin && typeof this.kernel.plugin.init === "function") {
+            await this.kernel.plugin.init()
+          }
+        },
+        exists: async () => this.kernel.exists("plugin/code")
+      },
       {
         kind: "prototype",
         root: path.resolve(home, "prototype/system"),