pinokiod 3.6.30 → 3.6.32

package/kernel/api/index.js

@@ -121,10 +121,8 @@ 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 })
 
 
 
@@ -354,20 +352,13 @@ class Api {
     let modpath
     if (matched_repo.length > 0) {
       let repo_uri = matched_repo[0]
-      if (!repo_uri.endsWith(".git")) {
-        repo_uri = repo_uri + ".git"
-      }
 
-      let repopath = this.gitPath[repo_uri]
-      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)
-      }
+      let relative_path = uri
+        .replace(repo_uri, "")    // remove the git repo uri
+        .slice(1)                 // remove the leading '/' for relative path
 
+      let repopath = this.gitPath[repo_uri]
+      modpath = path.resolve(repopath, relative_path)
     } else {
       //console.log("no matching gitpath")
     }
@@ -831,7 +822,6 @@ class Api {
   //            }
               this.ondata(m)
             })
-            console.log("EXEC RESULT", { result })
           }
 
 
@@ -1136,35 +1126,6 @@ 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) {
     /**************************************************************
     *
@@ -1211,64 +1172,38 @@ class Api {
     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 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: "uri doesn't exist \r\n" + JSON.stringify(request, null, 2)
-          })
-        }
+      if (!script) {
+        this.ondata({
+          id: request.path,
+          type: "error",
+          data: "the endpoint does not exist: " + request.uri,
+        })
       } else {
-        console.log({ request })
-        let { cwd, script } = await this.resolveScript(request.path)
-        request.cwd = cwd
+        // 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
 
-        if (!script) {
+          this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
+
+        } else {
           this.ondata({
             id: request.path,
             type: "error",
-            data: "the endpoint does not exist: " + request.uri,
+            data: "missing attribute: run"
           })
-        } 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,24 +588,6 @@ 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 := {
@@ -625,8 +607,6 @@ class Bin {
       this.client = null
     }
 
-    console.log("install", req)
-
     let requirements = JSON.parse(req.params)
 
     for(let x=0; x<10; x++) {
@@ -700,29 +680,17 @@ 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.installed.conda.has(name)
+      return this.kernel.bin.installed.conda.has(name)
     } else if (type === "pip") {
-      return this.installed.pip && this.installed.pip.has(name)
+      return this.kernel.bin.installed.pip && this.kernel.bin.installed.pip.has(name)
     } else if (type === "brew") {
-      return this.installed.brew.has(name)
+      return this.kernel.bin.installed.brew.has(name)
     } else {
       // check kernel/bin/<module>.installed()
       let filepath = path.resolve(__dirname, "..", "kernel", "bin", name + ".js")
-      let mod = this.mod[name]
+      let mod = this.kernel.bin.mod[name]
       let installed = false
       if (mod.installed) {
         installed = await mod.installed()
@@ -730,97 +698,6 @@ 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,11 +19,6 @@ 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,7 +26,6 @@ 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: {
@@ -43,29 +42,7 @@ class Kernel {
   schema = "<=3.7.0"
   constructor(store) {
     this.fetch = fetch
-
-    // 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.store = store
     this.arch = os.arch()
     this.os = os
     this.platform = os.platform()
@@ -409,7 +386,6 @@ class Kernel {
     }
   }
   async init(options) {
-    console.time(">>>>>>>>>>>>>> A")
     let home = this.store.get("home")
 
     // reset shells if they exist
@@ -476,9 +452,7 @@ class Kernel {
     }
     this.procs = {}
     this.template = new Template()
-    console.timeEnd(">>>>>>>>>>>>>> A")
     try {
-      console.time(">>>>>>>>>>>>>> B")
       if (this.homedir) {
 
         // 0. create homedir
@@ -516,17 +490,14 @@ 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,
@@ -593,16 +564,12 @@ 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,
@@ -612,18 +579,15 @@ class Kernel {
             return this.api.get_proxy_url("/proxy", port)
           },
         })
-        console.timeEnd(">>>>>>>>>>>>>> E template.init")
-        console.time(">>>>>>>>>>>>>> F sys.init")
         this.sys = new Sysinfo()
+        console.time("sys init")
         await this.sys.init(this)
-        console.timeEnd(">>>>>>>>>>>>>> F sys.init")
+        console.timeEnd("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,9 +103,6 @@ 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
@@ -123,6 +120,7 @@ class Shell {
 
     this.env.CMAKE_OBJECT_PATH_MAX = 1024
     this.env.PYTORCH_ENABLE_MPS_FALLBACK = 1
+    this.env.TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD = 1
 //    this.env.PIP_REQUIRE_VIRTUALENV = "true"
 //    this.env.NPM_CONFIG_USERCONFIG = this.kernel.path("user_npmrc")
 //    this.env.NPM_CONFIG_GLOBALCONFIG = this.kernel.path("global_npmrc")
@@ -277,12 +275,11 @@ class Shell {
       return response
     } else {
       let response = await this.request(params, async (stream) => {
-        if (ondata) ondata(stream)
-//        if (stream.prompt) {
-//          this.resolve()
-//        } else {
-//          if (ondata) ondata(stream)
-//        }
+        if (stream.prompt) {
+          this.resolve()
+        } else {
+          if (ondata) ondata(stream)
+        }
       })
       return response
     }
@@ -291,10 +288,7 @@ class Shell {
   }
   emit(message) {
     if (this.ptyProcess) {
-//      console.log("write", { message, input: this.input })
-      if (this.input) {
-        this.ptyProcess.write(message)
-      }
+      this.ptyProcess.write(message)
     }
   }
   send(message, newline, cb) {
@@ -376,9 +370,6 @@ 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
     }
@@ -910,7 +901,6 @@ class Shell {
     }
   }
   kill(message, force) {
-    console.log("KILL")
 
     this.done = true
     this.ready = false
@@ -1018,11 +1008,6 @@ ${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)
@@ -1030,10 +1015,8 @@ ${cleaned}
         id: this.id,
         raw: msg,
         cleaned,
-        state: cleaned,
-        shell_id: this.id
+        state: cleaned
       }
-      this.state = cleaned
       if (this.cb) this.cb(response)
 
       // Decide whether to kill or continue
@@ -1048,15 +1031,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.input || this.persistent) {
-//                if (this.cb) this.cb({
-//                  //raw: cached_msg,
-//                  //raw: msg,
-//                  //raw: "",
-//                  cleaned,
-//                  state: cleaned,
-//                  prompt: true
-//                })
+              if (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,7 +429,6 @@ 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/util.js

@@ -14,9 +14,6 @@ const groupReplacement = "$$$";
 const h = "[^\\S\\r\\n]";  // simulate `\h`
 const returnPattern = /\r/g;
 const returnReplacement = "\\r";
-const {
-  glob
-} = require('glob')
 
 
 // asar handling for go-get-folder-size
@@ -39,20 +36,26 @@ const du = async (folderpath) => {
 const is_port_available = async (port) => {
   return new Promise((resolve) => {
     const server = http.createServer();
+    console.log("> Checking port availability", port)
     try {
       server.listen(port, (err) => {
         if (err) {
+          console.log("> [1 port not available]", err)
           resolve(false); // Port is occupied
         } else {
+          console.log("> [2 port available] test server started. closing test server now.")
           server.close(() => {
+            console.log("> Test server closed.")
             resolve(true); // Port is free
           }); // Close the server immediately after testing
         }
       });
       server.on('error', (err) => {
+        console.log("> [3 port not available]", err);
         resolve(false); // Port is occupied
       });
     } catch (e) {
+      console.log("> [4 port not available]", err)
       resolve(false) // port not available
     }
   });
@@ -196,30 +199,6 @@ const escapeStringRegexp = (string) => {
 		.replace(/-/g, '\\x2d');
 }
 
-const find_python = async (root) => {
-  let python_pattern
-  if (os.platform() === "win32") {
-    python_pattern = "**/python.exe";
-  } else {
-    python_pattern = "**/python"; // Matches python, python3, python3.x
-  }
-  const pythonBinaries = await glob(python_pattern, { nodir: true, cwd: root });
-  return pythonBinaries
-}
-const find_venv = async (root) => {
-  let python_pattern
-  if (os.platform() === "win32") {
-    python_pattern = "**/python.exe";
-  } else {
-    python_pattern = "**/python"; // Matches python, python3, python3.x
-  }
-  const pythonBinaries = await glob(python_pattern, { nodir: true, cwd: root, absolute: true });
-  const venvs = pythonBinaries.map((p) => {
-    return path.resolve(p, "../..") 
-  })
-  return venvs
-}
-
 const update_env = async (filepath, changes) => {
   const env = await fs.promises.readFile(filepath, "utf8")
   let append = false;
@@ -257,5 +236,5 @@ const update_env = async (filepath, changes) => {
   await fs.promises.writeFile(filepath, newval)
 };
 module.exports = {
-  parse_env, log_path, api_path, update_env, parse_env_detail, openfs, port_running, du, is_port_available, find_python, find_venv
+  parse_env, log_path, api_path, update_env, parse_env_detail, openfs, port_running, du, is_port_available
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.6.30",
+  "version": "3.6.32",
   "description": "",
   "main": "index.js",
   "scripts": {

package/script/index.js

@@ -4,16 +4,6 @@ const os = require('os')
 const platform = os.platform()
 const Server = require('../server')
 class Store {
-  constructor() {
-    let o
-    try {
-      let str = fs.readFileSync(path.resolve(__dirname, "pinokio.json"), "utf8")
-      o = JSON.parse(str)
-    } catch(e) {
-      o = {}
-    }
-    this.store =  o
-  }
   set(key, val) {
     let o
     try {
@@ -23,7 +13,6 @@ class Store {
       o = {}
     }
     o[key] = val
-    this.store = o
     fs.writeFileSync(path.resolve(__dirname, "pinokio.json"), JSON.stringify(o, null, 2))
   }
   get(key) {
@@ -42,7 +31,6 @@ class Store {
       console.log("before delete", o)
       delete o[key]
       console.log("after delete", o)
-      this.store = o
       fs.writeFileSync(path.resolve(__dirname, "pinokio.json"), JSON.stringify(o, null, 2))
     } catch (e) {
     }