pinokiod 7.2.18 → 7.3.1

package/kernel/bin/index.js

@@ -22,6 +22,10 @@ const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { buildCondaListFromMeta } = require('./conda-meta')
+const {
+  isExpectedSqlitePinned,
+  isWindowsPythonSslFixed,
+} = require('./conda-pins')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
 const fse = require('fs-extra')
@@ -348,6 +352,8 @@ class Bin {
     let conda_check = {}
     let conda = new Set()
     let conda_versions = {}
+    let conda_builds = {}
+    this.correct_conda = false
 
     //////////////////////////////////////////////////////////////////
     // exception handling
@@ -386,8 +392,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
             }
@@ -404,10 +412,13 @@ class Bin {
             // Use sqlite to check if `conda update -y --all` went through successfully
             // sometimes it just fails silently so need to check
             if (name === "sqlite") {
-              if (String(version) === "3.47.2") {
+              if (isExpectedSqlitePinned(this.platform, version)) {
                 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 +427,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 +442,7 @@ class Bin {
 
     this.installed_initialized = false
     this.requirements_cache = {}
+    this.correct_conda = false
 
     //this.installed = {}
 

package/kernel/environment.js

@@ -3,189 +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)}`)
-  }
-
-  if (process.platform === "darwin") await fs.promises.writeFile(path.resolve(root, ".metadata_never_index"), "", { flag: "a" }).catch(() => {})
-
-  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
@@ -620,21 +438,18 @@ const requirements = async (script, cwd, kernel) => {
   let requires_instantiation = false
   if (script) {
     let pre
-    if (Array.isArray(script.pre)) {
+    if (script.pre) {
       pre = script.pre
-    } else if (Array.isArray(script.env)) {
+    } else if (script.env) {
       pre = script.env
     }
     if (pre) {
       let env = await get2(cwd, kernel)
       for(let item of pre) {
-        if (!item || typeof item !== "object") {
-          continue
-        }
         let env_key
-        if (typeof item.env === "string" && item.env) {
+        if (item.env) {
           env_key = item.env
-        } else if (typeof item.key === "string" && item.key) {
+        } else if (item.key) {
           env_key = item.key
           item.env = item.key
         }
@@ -643,20 +458,11 @@ const requirements = async (script, cwd, kernel) => {
           if (!item.index) {
             item.index = 0
           }
-          if (typeof item.host === "string" && item.host.trim()) {
-            const host = item.host.trim()
-            let parsedHost = ""
-            try {
-              const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(host);
-              const url = new URL(hasProtocol ? host : `https://${host}`);
-              parsedHost = url.host
-            } catch (e) {
-              item.host = ""
-            }
-            if (parsedHost) {
-              item.host = parsedHost
-              item.val = await kernel.kv.get(item.host, item.index)
-            }
+          if (item.host) {
+            const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(item.host);
+            const url = new URL(hasProtocol ? item.host : `https://${item.host}`);
+            item.host = url.host
+            item.val = await kernel.kv.get(item.host, item.index)
           } else {
             item.host = ""
           }
@@ -1022,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"),

package/kernel/index.js

@@ -40,11 +40,9 @@ const Git = require('./git')
 const Connect = require('./connect')
 const Favicon = require('./favicon')
 const AppLauncher = require('./app_launcher')
-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');
@@ -56,37 +54,9 @@ 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.3.0"
+  schema = "<=7.0.0"
   constructor(store) {
     this.fetch = fetch
 
@@ -415,9 +385,6 @@ class Kernel {
   path(...args) {
     return path.resolve(this.homedir, ...args)
   }
-  systemPath(...args) {
-    return path.resolve(__dirname, "..", "system", ...args)
-  }
   exists(...args) {
     if (args) {
       let abspath = this.path(...args)
@@ -497,30 +464,6 @@ 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
@@ -1032,7 +975,6 @@ class Kernel {
     this.loader = new Loader()
     this.bin = new Bin(this)
     this.api = new Api(this)
-    this.watch = new WatchManager(this)
     this.python = new Python(this)
     this.shell = new Shells(this)
     this.appLauncher = new AppLauncher(this)
@@ -1063,7 +1005,6 @@ class Kernel {
       args: {},
     }
     this.procs = {}
-    this.activeProcessWaits = {}
     this.template = new Template()
     try {
       if (this.homedir) {
@@ -1110,10 +1051,6 @@ class Kernel {
 
         // 2. mkdir all the folders if not already created
         await Environment.init_folders(this.homedir, 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/kernel/plugin.js

@@ -1,14 +1,39 @@
-const fs = require('fs')
-const PluginSources = require("./plugin_sources")
-
+const path = require('path')
+const { glob } = require('glob')
+const Info = require("./info")
 class Plugin {
   constructor(kernel) {
     this.kernel = kernel
   }
   async setConfig() {
+    let plugin_dir = path.resolve(this.kernel.homedir, "plugin")
     this.cache = {}
 
-    const plugins = await PluginSources.loadPluginMenu(this.kernel)
+    let plugin_paths = await glob('**/pinokio.js', { cwd: plugin_dir })
+
+    let plugins = []
+    for(let plugin_path of plugin_paths) {
+      let config = await this.kernel.require(path.resolve(plugin_dir, plugin_path))
+      if (config && config.run && Array.isArray(config.run)) {
+        let invalid
+        for(let key in config) {
+          if (typeof config[key] === "function") {
+            invalid = true
+          }
+        }
+        if (invalid) {
+          continue
+        }
+
+        let chunks = plugin_path.split(path.sep)
+        let cwd = chunks.slice(0, -1).join("/")
+        config.image = "/asset/plugin/" + cwd + "/" + config.icon 
+        plugins.push({
+          href: "/run/plugin/" + chunks.join("/"),
+          ...config
+        })
+      }
+    }
 
     this.config = {
       menu: plugins.map((plugin) => {
@@ -23,10 +48,37 @@ class Plugin {
     if (!exists) {
       await fs.promises.mkdir(this.kernel.path("plugin"), { recursive: true }).catch((e) => {})
     }
-    await this.setConfig()
+    let code_exists = await this.kernel.exists("plugin/code")
+    console.log({ code_exists })
+    if (!code_exists) {
+      if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
+        await this.kernel.exec({
+          //message: "git clone https://github.com/peanutcocktail/plugin",
+          //message: "git clone https://github.com/pinokiocomputer/plugin",
+          message: "git clone https://github.com/pinokiocomputer/code",
+          path: this.kernel.path("plugin")
+        }, (e) => {
+          process.stdout.write(e.raw)
+        })
+        await this.setConfig()
+        return
+      }
+    } else {
+      await this.setConfig()
+    }
   }
   async update() {
-    await this.setConfig()
+    if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
+      let exists = await this.kernel.exists("plugin")
+      if (!exists) {
+        await this.kernel.exec({
+          message: "git pull",
+          path: this.kernel.path("plugin")
+        }, (e) => {
+          process.stdout.write(e.raw)
+        })
+      }
+    }
   }
 }
 module.exports = Plugin

package/kernel/prototype.js

@@ -3,7 +3,6 @@ const path = require('path')
 const { glob, sync, hasMagic } = require('glob-gitignore')
 const marked = require('marked')
 const matter = require('gray-matter');
-const PluginSources = require("./plugin_sources")
 class Proto {
   constructor(kernel) {
     this.kernel = kernel
@@ -149,9 +148,6 @@ class Proto {
 
 
       if (response) {
-        if (response.success) {
-          response.success = PluginSources.normalizeLauncherSuccessPlugin(response.success, req.params.tool)
-        }
         return response
       } else {
         return { success: "/p/" + name + "/dev" }

package/kernel/shell.js

@@ -20,7 +20,6 @@ const { applyWindowsNodePackageManagerEnv } = require('./windows_node_package_ma
 const ShellParser = require('./shell_parser')
 const AnsiStreamTracker = require('./ansi_stream_tracker')
 const ShellStateSync = require('./shell_state_sync')
-const ShellRunTemplate = require('./api/shell_run_template')
 const home = os.homedir()
 
 function normalizeComparablePath(filePath, platform) {
@@ -294,8 +293,6 @@ class Shell {
       }
     }
 
-    setDefaultEnvValue(this.env, "HF_HUB_DISABLE_UPDATE_CHECK", "1")
-
     if (this.platform === "win32") {
       // Hugging Face file symlinks regularly fail on non-admin Windows setups.
       // Default to no-symlink cache mode unless the user/app explicitly overrides it.
@@ -311,7 +308,7 @@ class Shell {
         delete this.env[key]
       }
       let val = this.env[key]
-      if (!ShellRunTemplate.isPinokioEnvArgKey(key) && /[\r\n]/.test(val)) {
+      if (/[\r\n]/.test(val)) {
         const replaced = val.replaceAll(/[\r\n]+/g, ' ');
         this.env[key] = replaced
 //        delete this.env[key]
@@ -365,9 +362,6 @@ class Shell {
   }
   quoteArgForShell(value, shellName=this.shell) {
     const input = value == null ? "" : String(value)
-    if (ShellRunTemplate.hasEnvArgMarker(input)) {
-      return ShellRunTemplate.quoteEnvArgComposite(input, shellName)
-    }
     if (this.isCmdShell(shellName)) {
       return `"${input.replace(/([()%!^"<>&|])/g, '^$1')}"`
     }
@@ -415,7 +409,6 @@ class Shell {
     this.userActive = false
     this.decsyncBuffer = ''
     this.stateSync.reset()
-    this.envArgsPreviewed = false
 
     /*
       params := {
@@ -547,9 +540,6 @@ class Shell {
         //}
       }
     }
-    if (params._pinokio_cmd_delayed_expansion && this.isCmdShell(this.shell) && !this.args.includes("/V:ON")) {
-      this.args.push("/V:ON")
-    }
 
     // 3. path => path can be http, relative, absolute
     this.path = params.path
@@ -767,16 +757,6 @@ class Shell {
     }
     this.stateSync.invalidate({ clearTail: true })
   }
-  emitEnvArgsPreview(params) {
-    if (!params || !Array.isArray(params._pinokio_env_args) || params._pinokio_env_args.length === 0 || this.envArgsPreviewed) {
-      return
-    }
-    this.envArgsPreviewed = true
-    const raw = ShellRunTemplate.formatEnvArgsPreview(params._pinokio_env_args)
-    if (raw && this.ondata) {
-      this.ondata({ raw })
-    }
-  }
   async run(params, cb) {
     let r = await this.request(params, cb)
     return r
@@ -1382,7 +1362,6 @@ class Shell {
   }
   async exec(params) {
     this.parser = new ShellParser()
-    this.emitEnvArgsPreview(params)
     params = await this.activate(params)
     this.cmd = this.build(params)
     let res = await new Promise((resolve, reject) => {
@@ -1750,7 +1729,7 @@ class Shell {
       cmd: this.cmd,
       index: this.index,
       group: this.group,
-      env: ShellRunTemplate.redactEnvArgs(this.env),
+      env: this.env,
       done: this.done,
       ready: this.ready,
       id: this.id,