pinokiod 3.6.28 → 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("");
@@ -795,7 +808,6 @@ class Api {
           } else {
             // 11. actually make the rpc call
             result = await this.run(resolved.method, rpc, (stream, type) => {
-              console.log("RUN RESULT", { stream ,type })
               let m = {
                 id: request.path,
                 caller: request.caller,
@@ -1124,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) {
     /**************************************************************
     *
@@ -1165,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,56 +588,23 @@ class Bin {
       }
 //    }
   }
-  async install2(req, ondata) {
-    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"
-      })
+  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
     }
-    requirements = requirements.concat([{
-      name: "py"
-    }, {
-      name: "cloudflared"
-    }, {
-      name: "playwright"
-    }, {
-      name: "huggingface"
-    }, {
-      name: "uv"
-    }])
+  }
+  async install2(req, ondata) {
+    let { requirements, install_required, requirements_pending, error } = await this.check_bin()
     req.params = JSON.stringify(requirements)
-    let res = await this.install(req, ondata)
-    return res
+    if (this.install_required) {
+      let res = await this.install(req, ondata)
+      return res
+    }
   }
   async install(req, ondata) {
     /*
@@ -733,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()
@@ -751,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

@@ -40,7 +40,7 @@ class Kernel {
   //schema = ">=1.0.0"
   //schema = "<=2.1.0"
   //schema = "<=3.2.0"
-  schema = "<=3.6.0"
+  schema = "<=3.7.0"
   constructor(store) {
     this.fetch = fetch
 
@@ -409,6 +409,7 @@ class Kernel {
     }
   }
   async init(options) {
+    console.time(">>>>>>>>>>>>>> A")
     let home = this.store.get("home")
 
     // reset shells if they exist
@@ -475,7 +476,9 @@ class Kernel {
     }
     this.procs = {}
     this.template = new Template()
+    console.timeEnd(">>>>>>>>>>>>>> A")
     try {
+      console.time(">>>>>>>>>>>>>> B")
       if (this.homedir) {
 
         // 0. create homedir
@@ -513,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,
@@ -587,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,
@@ -602,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))
@@ -692,6 +707,7 @@ class Kernel {
       this.template.update(info)
       this.sysinfo = info
       this.gpu = info.gpu
+      this.gpu_model = info.gpu_model
       this.gpus = info.gpus
     } catch (e) {
       console.log("sysinfo error", e)

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
@@ -288,7 +291,7 @@ class Shell {
   }
   emit(message) {
     if (this.ptyProcess) {
-      console.log("write", { message, input: this.input })
+//      console.log("write", { message, input: this.input })
       if (this.input) {
         this.ptyProcess.write(message)
       }
@@ -1015,7 +1018,11 @@ ${cleaned}
 
   }
   stream(msg, callback) {
-    console.log("vt write", msg)
+    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)
@@ -1023,9 +1030,10 @@ ${cleaned}
         id: this.id,
         raw: msg,
         cleaned,
-        state: cleaned
+        state: cleaned,
+        shell_id: this.id
       }
-      console.log({ response })
+      this.state = cleaned
       if (this.cb) this.cb(response)
 
       // Decide whether to kill or continue

package/kernel/sysinfo.js

@@ -5,48 +5,68 @@ 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() {
     let g = await system.graphics()
     let gpus
     if (g && g.controllers && g.controllers.length > 0) {
-      gpus = g.controllers.map((x) => { return x.vendor.toLowerCase() })
+      gpus = g.controllers.map((x) => {
+        return {
+          name: x.vendor.toLowerCase(),
+          model: x.model.toLowerCase()
+        }
+      })
     } else {
       gpus = []
     }
 
-    let is_nvidia = gpus.find(gpu => /nvidia/i.test(gpu))
-    let is_amd = gpus.find(gpu => /(amd|advanced micro devices)/i.test(gpu))
-    let is_apple = gpus.find(gpu => /apple/i.test(gpu))
+    let is_nvidia = gpus.find(gpu => /nvidia/i.test(gpu.name))
+    let is_amd = gpus.find(gpu => /(amd|advanced micro devices)/i.test(gpu.name))
+    let is_apple = gpus.find(gpu => /apple/i.test(gpu.name))
 
     let gpu
+    let gpu_model
     if (is_nvidia) {
       gpu = "nvidia"
+      gpu_model = is_nvidia.model
     } else if (is_amd) {
       gpu = "amd"
+      gpu_model = is_amd.model
     } else if (is_apple) {
       gpu = "apple"
+      gpu_model = is_apple.model
     } else if (gpus.length > 0) {
-      gpu = gpus[0]
+      gpu = gpus[0].name
+      gpu_model = gpus[0].model
     } else {
       gpu = "none"
     }
@@ -54,6 +74,7 @@ class Sysinfo {
     this.info.graphics = g
     this.info.gpus = gpus
     this.info.gpu = gpu
+    this.info.gpu_model = gpu_model
 
   }
 //  async time() {