pinokiod 3.8.1 → 3.8.6

package/kernel/api/fs/index.js

@@ -75,16 +75,18 @@ class FS {
     /*
       params := {
         path: <filepath>,
-        mode: "view(default)|open"
+        command: "view(default)|open|<any command in PATH>"
       }
       open finder/file explorer at path
     */
     let dirPath = path.resolve(req.cwd, req.params.path)
     ondata({ raw: `\r\nopening path: ${dirPath}\r\n` })
-    if (req.params.mode) {
-      Util.openfs(dirPath, req.params.mode)
+    if (req.params.command) {
+      Util.openfs(dirPath, req.params, kernel)
+    } else if (req.params.mode) {
+      Util.openfs(dirPath, req.params, kernel)
     } else {
-      Util.openfs(dirPath)
+      Util.openfs(dirPath, {}, kernel)
     }
   }
 

package/kernel/api/index.js

@@ -119,21 +119,22 @@ class Api {
     return result
   }
   async stop(req, ondata) {
+    console.log(">>>>>>>>>>>>>>>>>> STOP")
     // 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.time("stop 1")
 
     let requestPath = this.filePath(req.params.uri)
 
-
-
     let { cwd, script } = await this.resolveScript(requestPath)
-    console.log("STOP", { script })
     if (script.on) {
       if (script.on.stop) {
         await this.process(script.on.stop) 
       }
     }
+    console.timeEnd("stop 1")
 
+    console.time("stop 2")
     // reset modules
     let modpath = this.resolvePath(cwd, req.params.uri)
     console.log("STOP modpath", modpath)
@@ -159,10 +160,15 @@ class Api {
 
     // stop all proxies
     this.stopProxy({ script: requestPath })
+    console.timeEnd("stop 2")
 
     // stop all cloudflare tunnels
 
+    console.time("stop 3")
     await this.kernel.stopCloudflare({ path: requestPath })
+    console.timeEnd("stop 3")
+
+    console.time("stop 4")
 
     // if there are any pending waiters, delete them
 
@@ -179,6 +185,7 @@ class Api {
       id: requestPath,
       type: "disconnect"
     })
+    console.timeEnd("stop 4")
     return true
   }
   async startScripts() {
@@ -352,13 +359,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")
     }
@@ -1121,6 +1135,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) {
     /**************************************************************
     *
@@ -1162,43 +1205,67 @@ 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) {
@@ -1229,12 +1296,16 @@ class Api {
 
       // Kernel Call
       let resolved = await this.resolveMethod(request)
+      let id = request.id ? request.id : request.method 
+      if (request.id) {
+        this.running[request.id] = true
+      }
       try {
         resolved.dirname = resolved.dirname
         let result = await this.run(resolved.method, request, (stream, type) => {
           this.ondata({
             kernel: true,
-            id: request.method,
+            id,
             type: (type ? type : "stream"),
             data: stream,
             rpc: request,
@@ -1243,7 +1314,7 @@ class Api {
         })
         this.ondata({
           kernel: true,
-          id: request.method,
+          id,
           type: "result",
           data: result,
           rpc: request,

package/kernel/bin/index.js

@@ -37,12 +37,28 @@ class Bin {
     this.arch = os.arch()
     this.platform = os.platform()
   }
+  async shell_kill(params, ondata) {
+    console.log("shell_kill", params)
+    this.kernel.shell.kill(params.params)
+  }
+  async shell_start(params, ondata) {
+    params.path = params.path || this.path()
+    console.log("this.client?", this.client)
+    if (this.client) {
+      params.cols = this.client.cols
+      params.rows = this.client.rows
+    }
+    console.log({ params })
+    let response = await this.kernel.shell.start(params, null, ondata)
+    return response
+  }
   async exec(params, ondata) {
     params.path = params.path || this.path()
     if (this.client) {
       params.cols = this.client.cols
       params.rows = this.client.rows
     }
+    console.log({ params })
     let response = await this.kernel.shell.run(params, null, ondata)
     return response
   }
@@ -646,6 +662,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 := {
@@ -665,6 +699,8 @@ class Bin {
       this.client = null
     }
 
+    console.log("install", req)
+
     let requirements = JSON.parse(req.params)
 
     for(let x=0; x<10; x++) {
@@ -738,17 +774,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()
@@ -756,6 +804,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

@@ -20,6 +20,15 @@ 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"), this.kernel.path("bin/npm/bin")],
+      NPM_CONFIG_PREFIX: this.kernel.path("bin/npm"),
+      npm_config_prefix: this.kernel.path("bin/npm"),
+      PNPM_HOME: this.kernel.path("bin/npm"),
+      pnpm_home: this.kernel.path("bin/npm"),
+    }
+  }
   async uninstall(req, ondata) {
     await this.kernel.bin.exec({
       message: "conda remove nodejs pnpm",

package/kernel/index.js

@@ -7,6 +7,7 @@ const fastq = require('fastq')
 const fetch = require('cross-fetch');
 const waitOn = require('wait-on');
 const system = require('systeminformation');
+const shellPath = require('shell-path');
 const Sysinfo = require('./sysinfo')
 const portfinder = require('portfinder-cp');
 const { execSync } = require('child_process')
@@ -26,6 +27,8 @@ const Config = require("./pinokio.json")
 const Info = require('./info')
 const Pipe = require("../pipe")
 const Cloudflare = require('./api/cloudflare')
+const Store = require('./store')
+const Proto = require('./prototype')
 const VARS = {
   pip: {
     install: {
@@ -42,7 +45,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()
@@ -52,7 +77,9 @@ class Kernel {
     this.envs = {}
     this.info = new Info(this)
     this.pipe = new Pipe(this)
+    this.proto = new Proto(this)
     this.cloudflare = new Cloudflare()
+    this.shellpath = shellPath.sync()
   }
   /*
     kernel.env() => return the system environment
@@ -513,6 +540,7 @@ class Kernel {
         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,
@@ -616,6 +644,9 @@ class Kernel {
         await fs.promises.writeFile(this.path("logs/system.json"), JSON.stringify(this.i, null, 2))
         let pwpath = this.bin.path("playwright/node_modules/playwright")
         this.playwright = (await this.loader.load(pwpath)).resolved
+
+
+        await this.proto.init()
       }
 
     } catch (e) {

package/kernel/info.js

@@ -45,6 +45,7 @@ class Info {
   exists(...args) {
     let cwd = path.dirname(this.caller())
     let resolved_path = path.resolve(cwd, ...args)
+    console.log({ cwd, resolved_path })
     return fs.existsSync(resolved_path)
   }
   local(...args) {

package/kernel/prototype.js

@@ -0,0 +1,47 @@
+const fs = require('fs')
+const path = require('path')
+class Proto {
+  constructor(kernel) {
+    this.kernel = kernel
+  }
+  async init() {
+
+    // if ~/pinokio/prototype doesn't exist, clone
+    let exists = await this.kernel.exists("prototype")
+    if (!exists) {
+      console.log("prototype doesn't exist. cloning...")
+      await this.kernel.exec({
+        message: "git clone https://github.com/peanutcocktail/prototype",
+        path: this.kernel.homedir
+      }, (e) => {
+        process.stdout.write(e.raw)
+      })
+    }
+    // get all prototypes
+    let prototype_dir = path.resolve(this.kernel.homedir, "prototype")
+    let prototypes = await fs.promises.readdir(prototype_dir, { withFileTypes: true })
+    prototypes = prototypes.filter(d => d.isDirectory()).map(d => d.name);
+    console.log({ prototypes })
+    this.items = []
+    this.kv = {}
+    for(let proto of prototypes) {
+      let pinokiojs = path.resolve(prototype_dir, proto, "pinokio.js")
+      let config = await this.kernel.require(pinokiojs)
+      console.log({ config })
+      if (config && config.type === "prototype") {
+        if (config.icon) {
+          config.icon = "/prototype/" + proto + "/" + config.icon
+        } else {
+          config.icon === "/pinokio-black.png"
+        }
+        let c = {
+          id: proto,
+          ...config
+        }
+        this.items.push(c)
+        this.kv[proto] = c
+      }
+    }
+  }
+}
+module.exports = Proto