pinokiod 3.6.29 → 3.6.30

package/kernel/api/index.js

@@ -121,8 +121,10 @@ class Api {
   async stop(req, ondata) {
     // 1. set the "stop" flag for the uri, so the next execution in the queue for the uri will NOT queue another task
     // 2. stream a message closing the socket
+    console.log("> stop", req)
 
     let requestPath = this.filePath(req.params.uri)
+    console.log({ requestPath })
 
 
 
@@ -352,13 +354,20 @@ class Api {
     let modpath
     if (matched_repo.length > 0) {
       let repo_uri = matched_repo[0]
-
-      let relative_path = uri
-        .replace(repo_uri, "")    // remove the git repo uri
-        .slice(1)                 // remove the leading '/' for relative path
+      if (!repo_uri.endsWith(".git")) {
+        repo_uri = repo_uri + ".git"
+      }
 
       let repopath = this.gitPath[repo_uri]
-      modpath = path.resolve(repopath, relative_path)
+      if (uri === repo_uri) {
+        modpath = path.resolve(repopath)
+      } else {
+        let relative_path = uri
+          .replace(repo_uri, "")    // remove the git repo uri
+          .slice(1)                 // remove the leading '/' for relative path
+        modpath = path.resolve(repopath, relative_path)
+      }
+
     } else {
       //console.log("no matching gitpath")
     }
@@ -568,9 +577,13 @@ class Api {
   }
   async step (request, rawrpc, input, i, total, args) {
 
-    await this.init()
+    await Promise.all([this.init, this.kernel.update_sysinfo])
 
-    await this.kernel.update_sysinfo()
+//    await this.init()
+//
+//    console.time("api.update_sysinfo")
+//    await this.kernel.update_sysinfo()
+//    console.timeEnd("api.update_sysinfo")
 
     // clear global regular expression object RegExp.lastMatch (memory leak prevention)
     let r = /\s*/g.exec("");
@@ -818,6 +831,7 @@ class Api {
   //            }
               this.ondata(m)
             })
+            console.log("EXEC RESULT", { result })
           }
 
 
@@ -1122,6 +1136,35 @@ class Api {
       this.process(request, resolve)
     })
   }
+  async get_default(repo_path) {
+    let p = path.resolve(repo_path, "pinokio.js")
+    // call 'process' based on the current status
+    let config = (await this.loader.load(p)).resolved
+    if (config && config.menu) {
+      if (typeof config.menu === "function") {
+        if (config.menu.constructor.name === "AsyncFunction") {
+          config.menu = await config.menu(this.kernel, this.kernel.info)
+        } else {
+          config.menu = config.menu(this.kernel, this.kernel.info)
+        }
+      }
+      // find the default item in the menu
+      let running = config.menu.filter((item) => {
+        return item.default
+      })
+      if (running.length > 0) {
+        let r = running[0]
+        if (r.href) {
+          if (r.href.startsWith("http")) {
+            return r.href
+          } else {
+            let href = path.resolve(repo_path, r.href)
+            return href
+          }
+        }
+      }
+    }
+  }
   async process(request, done) {
     /**************************************************************
     *
@@ -1163,41 +1206,69 @@ class Api {
 //    this.kernel.keys = (await this.loader.load(keypath)).resolved
 
     // init shell before running just to make sure the environment variables are fresh
+    console.time("shell.init")
     await this.kernel.shell.init()
+    console.timeEnd("shell.init")
 
     if (request.uri){
+
       this.counter++;
       // API Call
 
       request.path = this.resolvePath(this.userdir, request.uri)
-      let { cwd, script } = await this.resolveScript(request.path)
-      request.cwd = cwd
 
-      if (!script) {
-        this.ondata({
-          id: request.path,
-          type: "error",
-          data: "the endpoint does not exist: " + request.uri,
-        })
-      } else {
-        // 3. Check if the resolved endpoint has the "run" attribute and it's an array
-        //if (script.run && Array.isArray(script.run)) {
-        if (script.run) {
-
-          this.running[request.path] = true
-
-          this.done[request.path] = done
-
-          this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
 
+      // if the path is 
+      let relative = path.relative(this.kernel.homedir, request.path)
+      let chunks = relative.split(path.sep)
+      console.log({ chunks })
+      if (chunks.length == 2) {
+        // the script is requesting a uri of the git repo
+        // look for pinokio.js
+        let p = path.resolve(request.path, "pinokio.js")
+        let exists = await this.exists(p)
+        console.log({ p, exists })
+        if (exists) {
+          await this.launch(request, p)
         } else {
           this.ondata({
             id: request.path,
             type: "error",
-            data: "missing attribute: run"
+            data: "uri doesn't exist \r\n" + JSON.stringify(request, null, 2)
           })
         }
+      } else {
+        console.log({ request })
+        let { cwd, script } = await this.resolveScript(request.path)
+        request.cwd = cwd
+
+        if (!script) {
+          this.ondata({
+            id: request.path,
+            type: "error",
+            data: "the endpoint does not exist: " + request.uri,
+          })
+        } else {
+          // 3. Check if the resolved endpoint has the "run" attribute and it's an array
+          //if (script.run && Array.isArray(script.run)) {
+          if (script.run) {
+
+            this.running[request.path] = true
+
+            this.done[request.path] = done
+
+            this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
+
+          } else {
+            this.ondata({
+              id: request.path,
+              type: "error",
+              data: "missing attribute: run"
+            })
+          }
+        }
       }
+
     } else if (request.method) {
       let pass = 0;
       while(true) {

package/kernel/bin/index.js

@@ -588,6 +588,24 @@ class Bin {
       }
 //    }
   }
+  async path_exists(req, ondata) {
+    let abspath = this.kernel.api.resolvePath(this.kernel.api.userdir, req.params.uri)
+    if (abspath) {
+      console.log({ abspath })
+      let exists = await new Promise(r=>fs.access(abspath, fs.constants.F_OK, e => r(!e)))
+      return exists
+    } else {
+      return false
+    }
+  }
+  async install2(req, ondata) {
+    let { requirements, install_required, requirements_pending, error } = await this.check_bin()
+    req.params = JSON.stringify(requirements)
+    if (this.install_required) {
+      let res = await this.install(req, ondata)
+      return res
+    }
+  }
   async install(req, ondata) {
     /*
       req.params := {
@@ -607,6 +625,8 @@ class Bin {
       this.client = null
     }
 
+    console.log("install", req)
+
     let requirements = JSON.parse(req.params)
 
     for(let x=0; x<10; x++) {
@@ -680,17 +700,29 @@ class Bin {
     //}
     await this.init()
   }
+  async installed(r) {
+    if (Array.isArray(r.name)) {
+      for(let name of r.name) {
+        let installed = await this._installed(name, r.type)
+        if (!installed) return false
+      }
+      return true
+    } else {
+      let installed = await this._installed(r.name, r.type)
+      return installed
+    }
+  }
   async _installed(name, type) {
     if (type === "conda") {
-      return this.kernel.bin.installed.conda.has(name)
+      return this.installed.conda.has(name)
     } else if (type === "pip") {
-      return this.kernel.bin.installed.pip && this.kernel.bin.installed.pip.has(name)
+      return this.installed.pip && this.installed.pip.has(name)
     } else if (type === "brew") {
-      return this.kernel.bin.installed.brew.has(name)
+      return this.installed.brew.has(name)
     } else {
       // check kernel/bin/<module>.installed()
       let filepath = path.resolve(__dirname, "..", "kernel", "bin", name + ".js")
-      let mod = this.kernel.bin.mod[name]
+      let mod = this.mod[name]
       let installed = false
       if (mod.installed) {
         installed = await mod.installed()
@@ -698,6 +730,97 @@ class Bin {
       return installed
     }
   }
+  async check_bin() {
+    let requirements = [
+      { name: "conda", },
+      { name: "git", },
+      { name: "zip", },
+      { name: "node", },
+      { name: "ffmpeg", }
+    ]
+    let platform = os.platform()
+    if (platform === "win32") {
+      requirements.push({ name: "registry" })
+      requirements.push({ name: "vs" })
+    }
+    if (platform === "darwin") {
+      requirements.push({ name: "brew" })
+    }
+    if (platform === "linux") {
+      requirements.push({ name: "gxx" })
+    }
+    if (this.kernel.gpu === "nvidia") {
+      requirements.push({ name: "cuda", })
+    }
+    requirements = requirements.concat([
+      { name: "py" },
+      { name: "cloudflared" },
+      { name: "playwright" },
+      { name: "huggingface" },
+      { name: "uv" }
+    ])
+
+    let requirements_pending = !this.installed_initialized
+    let install_required = true
+    if (!requirements_pending) {
+      install_required = false
+      for(let i=0; i<requirements.length; i++) {
+        let r = requirements[i]
+        console.time(r.name)
+        let installed = await this.installed(r)
+        console.log({ r, installed })
+        console.timeEnd(r.name)
+        requirements[i].installed = installed
+        if (!installed) {
+          install_required = true
+        }
+      }
+    }
+
+    let error = null
+    try {
+      this.compatible()
+    } catch (e) {
+      error = e.message
+      install_required = true
+    }
+
+    this.install_required = install_required
+    this.requirements_pending = requirements_pending
+
+    console.log("check_bin finished 2")
+    return {
+      error,
+      requirements,
+      install_required,
+      requirements_pending
+    }
+
+  }
+  winBuildNumber() {
+    let osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());
+    let buildNumber = 0;
+    if (osVersion && osVersion.length === 4) {
+        buildNumber = parseInt(osVersion[3]);
+    }
+    return buildNumber;
+  }
+  compatible() {
+    if (this.kernel.platform === "win32") {
+      let buildNumber = this.winBuildNumber() 
+      if (buildNumber < 18309) {
+        // must use conpty for node-pty, and conpty is only supported in win>=18309
+        console.log("Windows buildNumber", buildNumber)
+        throw new Error(`Pinokio supports Windows release 18309 and up (current system: ${buildNumber}`)
+      }
+
+//      if (buildNumber > 25000) {
+//        console.log("Windows buildNumber", buildNumber)
+//        throw new Error(`Pinokio does not currently support Windows Canary (versions 25000 and up). The current system is ${buildNumber}`)
+//        
+//      }
+    }
+  }
   async sh(params, ondata) {
     let response = await this.kernel.shell.run(params, null, ondata)
     return response

package/kernel/bin/node.js

@@ -19,6 +19,11 @@ class Node {
   async installed() {
     return this.kernel.bin.installed.conda.has("nodejs") && this.kernel.bin.installed.conda.has("pnpm")
   }
+  env() {
+    return {
+      PATH: [this.kernel.path("bin/npm/bin")]
+    }
+  }
   async uninstall(req, ondata) {
     await this.kernel.bin.exec({
       message: "conda remove nodejs pnpm",

package/kernel/index.js

@@ -26,6 +26,7 @@ const Config = require("./pinokio.json")
 const Info = require('./info')
 const Pipe = require("../pipe")
 const Cloudflare = require('./api/cloudflare')
+const Store = require('./store')
 const VARS = {
   pip: {
     install: {
@@ -42,7 +43,29 @@ class Kernel {
   schema = "<=3.7.0"
   constructor(store) {
     this.fetch = fetch
-    this.store = store
+
+    // STORE
+    // Previously custom STORE could be passed in. This was to support both electron and server based initialization
+    // But this creates complexity because the store location is not fixed
+    // Migrating it to ~/.pinokio/config.json
+    //
+    // 1. does ~/.pinokio exist?
+    //  - load from that file
+    // 2. does ~/.pinokio NOT exist?
+    //  - save the passed in options to the `~/.pinokio`
+    //  - load the config
+
+    this.store = new Store()
+    let exists = this.store.exists()
+    console.log("Store exists?", exists)
+    if (!exists) {
+      console.log("doesn't exist")
+      // clone the store to the new store
+      this.store.clone(store.store)
+      // load from the store (this will be the last time this is used, since the next time it loads, it will load from the new store)
+    }
+    console.log("this.store", this.store.store())
+
     this.arch = os.arch()
     this.os = os
     this.platform = os.platform()
@@ -386,6 +409,7 @@ class Kernel {
     }
   }
   async init(options) {
+    console.time(">>>>>>>>>>>>>> A")
     let home = this.store.get("home")
 
     // reset shells if they exist
@@ -452,7 +476,9 @@ class Kernel {
     }
     this.procs = {}
     this.template = new Template()
+    console.timeEnd(">>>>>>>>>>>>>> A")
     try {
+      console.time(">>>>>>>>>>>>>> B")
       if (this.homedir) {
 
         // 0. create homedir
@@ -490,14 +516,17 @@ class Kernel {
 
 
       }
+      console.timeEnd(">>>>>>>>>>>>>> B")
 
 //      let contents = await fs.promises.readdir(this.homedir)
       //await this.bin.init()
       let ts = Date.now()
+      console.time(">>>>>>>>>>>>>> C bin.init")
       this.bin.init().then(() => {
         console.log("bin init finished")
         if (this.homedir) {
           this.shell.init().then(async () => {
+            this.bin.check_bin()
             if (this.envs) {
               this.template.update({
                 env: this.envs,
@@ -564,12 +593,16 @@ class Kernel {
           })
         }
       })
+      console.timeEnd(">>>>>>>>>>>>>> C bin.init")
       let ts2 = Date.now()
+      console.time(">>>>>>>>>>>>>> D api.init")
       await this.api.init()
+      console.timeEnd(">>>>>>>>>>>>>> D api.init")
 
       //await this.shell.init()
 
       if (this.homedir) {
+        console.time(">>>>>>>>>>>>>> E template.init")
         await this.template.init({
           kernel: this,
           system,
@@ -579,13 +612,18 @@ class Kernel {
             return this.api.get_proxy_url("/proxy", port)
           },
         })
+        console.timeEnd(">>>>>>>>>>>>>> E template.init")
+        console.time(">>>>>>>>>>>>>> F sys.init")
         this.sys = new Sysinfo()
         await this.sys.init(this)
+        console.timeEnd(">>>>>>>>>>>>>> F sys.init")
         let info = this.sys.info
 
         this.sysinfo = info
 
+        console.time(">>>>>>>>>>>>>> G getInfo")
         await this.getInfo()
+        console.timeEnd(">>>>>>>>>>>>>> G getInfo")
 
         await fs.promises.mkdir(this.path("logs"), { recursive: true }).catch((e) => { })
         await fs.promises.writeFile(this.path("logs/system.json"), JSON.stringify(this.i, null, 2))

package/kernel/shell.js

@@ -103,6 +103,9 @@ class Shell {
     if (this.env.CMAKE_GENERATOR) {
       delete this.env.CMAKE_GENERATOR
     }
+
+    this.env.NPM_CONFIG_PREFIX = this.kernel.path("bin/npm")
+    this.env.npm_config_prefix = this.kernel.path("bin/npm")
     
 //    if (this.env.CUDA_HOME) {
 //      delete this.env.CUDA_HOME
@@ -274,11 +277,12 @@ class Shell {
       return response
     } else {
       let response = await this.request(params, async (stream) => {
-        if (stream.prompt) {
-          this.resolve()
-        } else {
-          if (ondata) ondata(stream)
-        }
+        if (ondata) ondata(stream)
+//        if (stream.prompt) {
+//          this.resolve()
+//        } else {
+//          if (ondata) ondata(stream)
+//        }
       })
       return response
     }
@@ -287,7 +291,10 @@ class Shell {
   }
   emit(message) {
     if (this.ptyProcess) {
-      this.ptyProcess.write(message)
+//      console.log("write", { message, input: this.input })
+      if (this.input) {
+        this.ptyProcess.write(message)
+      }
     }
   }
   send(message, newline, cb) {
@@ -369,6 +376,9 @@ class Shell {
 
     // not connected => make a new connection => which means get a new prompt
     // if already connected => no need for a new prompt
+    if (params.input) {
+      this.input = params.input
+    }
     if (params.persistent) {
       this.persistent = params.persistent
     }
@@ -900,6 +910,7 @@ class Shell {
     }
   }
   kill(message, force) {
+    console.log("KILL")
 
     this.done = true
     this.ready = false
@@ -1007,6 +1018,11 @@ ${cleaned}
 
   }
   stream(msg, callback) {
+    if (msg === "\u0007") {
+      // Ignore bell sound escape character because it slows down everything and makes redundant sound
+      callback()
+      return
+    }
     this.vt.write(msg, () => {
       let buf = this.vts.serialize()
       let cleaned = this.stripAnsi(buf)
@@ -1014,8 +1030,10 @@ ${cleaned}
         id: this.id,
         raw: msg,
         cleaned,
-        state: cleaned
+        state: cleaned,
+        shell_id: this.id
       }
+      this.state = cleaned
       if (this.cb) this.cb(response)
 
       // Decide whether to kill or continue
@@ -1030,15 +1048,15 @@ ${cleaned}
           // todo: may need to handle cases when the command returns immediately with no output (example: 'which brew' returns immediately with no text if brew doesn't exist)
           setTimeout(() => {
             if (cache === cleaned) {
-              if (this.persistent) {
-                if (this.cb) this.cb({
-                  //raw: cached_msg,
-                  //raw: msg,
-                  //raw: "",
-                  cleaned,
-                  state: cleaned,
-                  prompt: true
-                })
+              if (this.input || this.persistent) {
+//                if (this.cb) this.cb({
+//                  //raw: cached_msg,
+//                  //raw: msg,
+//                  //raw: "",
+//                  cleaned,
+//                  state: cleaned,
+//                  prompt: true
+//                })
                 callback()
               } else {
                 callback()

package/kernel/shells.js

@@ -429,6 +429,7 @@ class Shells {
     }
   }
   rm(id) {
+    console.log("SHELL RM", id)
     for(let i=0; i<this.shells.length; i++) {
       let shell = this.shells[i]
       if (shell.id === id) {

package/kernel/store.js

@@ -0,0 +1,58 @@
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+class Store {
+  constructor() {
+    this.root = path.resolve(os.homedir(), ".pinokio")
+    if (!fs.existsSync(path.resolve(this.root))) {
+      fs.mkdirSync(path.resolve(this.root))
+    }
+  }
+  exists() {
+    let p =  path.resolve(this.root, "config.json")
+    return fs.existsSync(p)
+  }
+  clone(old) {
+    console.log("clone", old)
+    let p =  path.resolve(this.root, "config.json")
+    fs.writeFileSync(p, JSON.stringify(old, null, 2))
+  }
+  set(key, val) {
+    let o
+    try {
+      let str = fs.readFileSync(path.resolve(this.root, "config.json"), "utf8")
+      o = JSON.parse(str)
+    } catch(e) {
+      o = {}
+    }
+    o[key] = val
+    fs.writeFileSync(path.resolve(this.root, "config.json"), JSON.stringify(o, null, 2))
+  }
+  get(key) {
+    try {
+      let str = fs.readFileSync(path.resolve(this.root, "config.json"), "utf8")
+      let o = JSON.parse(str)
+      return o[key]
+    } catch (e) {
+      return null
+    }
+  }
+  delete(key) {
+    try {
+      let str = fs.readFileSync(path.resolve(this.root, "config.json"), "utf8")
+      let o = JSON.parse(str)
+      delete o[key]
+      fs.writeFileSync(path.resolve(this.root, "config.json"), JSON.stringify(o, null, 2))
+    } catch (e) {
+    }
+  }
+  store() {
+    try {
+      let str = fs.readFileSync(path.resolve(this.root, "config.json"), "utf8")
+      let o = JSON.parse(str)
+      return o
+    } catch (e) {
+    }
+  }
+}
+module.exports = Store

package/kernel/sysinfo.js

@@ -5,24 +5,34 @@ class Sysinfo {
   async init(kernel) {
     this.kernel = kernel
     this.info = {}
-    await this.static()
-    await this.refresh()
+    await Promise.all([this.static, this.refresh])
+//    await this.static()
+//    await this.refresh()
   }
   async static() {
-    await this.gpus()
-    await this.system()
-    await this.cpu()
-    await this.os()
-    await this.audio()
-    await this.env()
+    await Promise.all([this.gpus, this.system, this.cpu, this.os, this.audio, this.env])
+//    await this.gpus()
+//    await this.system()
+//    await this.cpu()
+//    await this.os()
+//    await this.audio()
+//    await this.env()
+
+
 //    await this.disk()
   }
   async refresh() {
 //    await this.time()
-    await this.memory()
-    await this.battery()
-    await this.proc()
-    await this.bluetooth()
+
+
+    await Promise.all([this.memory, this.battery, this.proc, this.bluetooth])
+//    await this.memory()
+//    await this.battery()
+//    await this.proc()
+//    await this.bluetooth()
+//
+
+
 //    await this.net()
   }
   async gpus() {