pinokiod 3.6.23 → 3.6.25

package/kernel/api/index.js

@@ -795,6 +795,7 @@ 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,
@@ -818,6 +819,7 @@ class Api {
   //            }
               this.ondata(m)
             })
+            console.log("EXEC RESULT", { result })
           }
 
 

package/kernel/api/process/index.js

@@ -1,4 +1,34 @@
 const waitOn = require('wait-on');
+const axios = require('axios');
+async function checkUrlStatus(url, message, interval, ondata) {
+  try {
+    console.log({ check: url, interval })
+    if (message) {
+      ondata({
+        raw: `\r\n${message}\r\n`
+      })
+    }
+    await axios.get(url, { timeout: interval });
+    return true;
+  } catch (error) {
+    console.log({ error })
+    return false;
+  }
+}
+async function waitForUrl(url, message, interval, ondata) {
+  let isUp = await checkUrlStatus(url, message, interval, ondata)
+  console.log({ isUp })
+  if (isUp) {
+    return
+  } else {
+    await new Promise((resolve, reject) => {
+      setTimeout(() => {
+        resolve()
+      }, interval)
+    })
+    await waitForUrl(url, message, interval, ondata)
+  }
+}
 class Process {
 //  async start(req, ondata, kernel) {
 //    /*
@@ -143,6 +173,15 @@ class Process {
 
     or
 
+    params := {
+      url: <URL>,
+      interval: (optional) how often to retry checking (in seconds)
+      message: (optional) the message to display while retrying (default: no message)
+    }
+
+    or
+
+
     params := {
       on: <wait-on condition https://github.com/jeffbski/wait-on>,
       message: (optional) Description to display while waiting,
@@ -176,6 +215,9 @@ class Process {
             this.resolve()
           }, ms)
         })
+      } else if (req.params.url) {
+        let interval = req.params.interval ? req.params.interval * 1000 : 1000
+        await waitForUrl(req.params.url, req.params.message, interval, ondata)
       } else if (req.params.on) {
         // Wait
         if (req.params.message) {

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.6.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()

package/kernel/shell.js

@@ -274,11 +274,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 +288,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 +373,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 +907,7 @@ class Shell {
     }
   }
   kill(message, force) {
+    console.log("KILL")
 
     this.done = true
     this.ready = false
@@ -1007,6 +1015,7 @@ ${cleaned}
 
   }
   stream(msg, callback) {
+    console.log("vt write", msg)
     this.vt.write(msg, () => {
       let buf = this.vts.serialize()
       let cleaned = this.stripAnsi(buf)
@@ -1016,6 +1025,7 @@ ${cleaned}
         cleaned,
         state: cleaned
       }
+      console.log({ response })
       if (this.cb) this.cb(response)
 
       // Decide whether to kill or continue
@@ -1030,15 +1040,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/util.js

@@ -36,26 +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)
+//    console.log("> Checking port availability", port)
     try {
       server.listen(port, (err) => {
         if (err) {
-          console.log("> [1 port not available]", 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.")
+//          console.log("> [2 port available] test server started. closing test server now.")
           server.close(() => {
-            console.log("> Test server closed.")
+//            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);
+//        console.log("> [3 port not available]", err);
         resolve(false); // Port is occupied
       });
     } catch (e) {
-      console.log("> [4 port not available]", err)
+//      console.log("> [4 port not available]", err)
       resolve(false) // port not available
     }
   });

package/package.json

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

package/script/index.js

@@ -4,6 +4,16 @@ 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 {
@@ -13,6 +23,7 @@ class Store {
       o = {}
     }
     o[key] = val
+    this.store = o
     fs.writeFileSync(path.resolve(__dirname, "pinokio.json"), JSON.stringify(o, null, 2))
   }
   get(key) {
@@ -31,6 +42,7 @@ 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) {
     }

package/server/index.js

@@ -28,6 +28,8 @@ const multer = require('multer');
 
 const ejs = require('ejs');
 
+const DEFAULT_PORT = 42000
+
 const ex = fn => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
 };
@@ -45,7 +47,8 @@ class Server {
   constructor(config) {
     this.tabs = {}
     this.agent = config.agent
-    this.port = config.port
+    this.port = DEFAULT_PORT
+//    this.port = config.port
     this.kernel = new Kernel(config.store)
 //    this.tunnels = {}
     this.version = {
@@ -1886,76 +1889,76 @@ class Server {
     // 5. existing home is NOT set + new home is set => go through with the "home" setting procedure
     // 6. existing home is NOT set + new home is NOT set => don't touch anything => the homedir will be the default home
 
-    // 2. HOME
-    // 2.1. Check if the config includes NEW_HOME => if so,
-    //    - move the HOME folder to NEW_HOME
-    //    - set HOME=NEW_HOME
-    //    - remove NEW_HOME
-    let existing_home = this.kernel.store.get("home")
-    let new_home = this.kernel.store.get("new_home")
-
-    if (existing_home) {
-      let exists = await fse.pathExists(existing_home)
-      if (exists) {
-        if (new_home) {
-          let new_home_exists = await fse.pathExists(new_home)
-          if (new_home_exists) {
-            // - existing home is set
-            // - existing home exists
-            // - new home is set
-            // - new home exists already
-            //    => delete store.new_home ==> will load at store.home
-            this.kernel.store.delete("new_home")
-          } else {
-            // - existing home is set
-            // - existing home exists
-            // - new home is set
-            // - new home does not exist
-            //    => run mv()
-            //    => update store.home
-            //    => delete store.new_home
-            await this.mv(existing_home, new_home)
-            this.kernel.store.set("home", new_home)
-            this.kernel.store.delete("new_home")
-          }
-        } else {
-          // - existing home is set
-          // - existing home exists
-          // - new home is not set
-          //    => This is most typical scenario => don't touch anything => the homedir will be the existing home
-        }
-      } else {
-        if (new_home) {
-          // - existing home is set
-          // - but the existing home path DOES NOT exist
-          // - new home is set
-          //    => This is an invalid scenario => Just to avoid disaster, just delete store.home and delete store.new_home
-          //    => the app will load at ~/pinokio
-          this.kernel.store.delete("home")
-          this.kernel.store.delete("new_home")
-        } else {
-          // - existing home is set
-          // - but the existing home path DOES NOT exist
-          // - new home is NOT set
-          //    => This is an invalid scenario => just delete store.home
-          //    => the app will load at ~/pinokio
-          this.kernel.store.delete("home")
-        }
-      }
-    } else {
-      if (new_home) {
-        // - existing home is NOT set
-        // - new home is set
-        //    => update store.home
-        //    => delete store.new_home
-        this.kernel.store.set("home", new_home)
-        this.kernel.store.delete("new_home")
-      } else {
-        // - existing home is NOT set
-        // - new home is NOT set
-        //    => don't touch anything => will load at ~/pinokio
-      }
-    }
+//    // 2. HOME
+//    // 2.1. Check if the config includes NEW_HOME => if so,
+//    //    - move the HOME folder to NEW_HOME
+//    //    - set HOME=NEW_HOME
+//    //    - remove NEW_HOME
+//    let existing_home = this.kernel.store.get("home")
+//    let new_home = this.kernel.store.get("new_home")
+//
+//    if (existing_home) {
+//      let exists = await fse.pathExists(existing_home)
+//      if (exists) {
+//        if (new_home) {
+//          let new_home_exists = await fse.pathExists(new_home)
+//          if (new_home_exists) {
+//            // - existing home is set
+//            // - existing home exists
+//            // - new home is set
+//            // - new home exists already
+//            //    => delete store.new_home ==> will load at store.home
+//            this.kernel.store.delete("new_home")
+//          } else {
+//            // - existing home is set
+//            // - existing home exists
+//            // - new home is set
+//            // - new home does not exist
+//            //    => run mv()
+//            //    => update store.home
+//            //    => delete store.new_home
+//            await this.mv(existing_home, new_home)
+//            this.kernel.store.set("home", new_home)
+//            this.kernel.store.delete("new_home")
+//          }
+//        } else {
+//          // - existing home is set
+//          // - existing home exists
+//          // - new home is not set
+//          //    => This is most typical scenario => don't touch anything => the homedir will be the existing home
+//        }
+//      } else {
+//        if (new_home) {
+//          // - existing home is set
+//          // - but the existing home path DOES NOT exist
+//          // - new home is set
+//          //    => This is an invalid scenario => Just to avoid disaster, just delete store.home and delete store.new_home
+//          //    => the app will load at ~/pinokio
+//          this.kernel.store.delete("home")
+//          this.kernel.store.delete("new_home")
+//        } else {
+//          // - existing home is set
+//          // - but the existing home path DOES NOT exist
+//          // - new home is NOT set
+//          //    => This is an invalid scenario => just delete store.home
+//          //    => the app will load at ~/pinokio
+//          this.kernel.store.delete("home")
+//        }
+//      }
+//    } else {
+//      if (new_home) {
+//        // - existing home is NOT set
+//        // - new home is set
+//        //    => update store.home
+//        //    => delete store.new_home
+//        this.kernel.store.set("home", new_home)
+//        this.kernel.store.delete("new_home")
+//      } else {
+//        // - existing home is NOT set
+//        // - new home is NOT set
+//        //    => don't touch anything => will load at ~/pinokio
+//      }
+//    }
   }
   async setConfig(config) {
     let home = this.kernel.store.get("home")
@@ -1980,13 +1983,14 @@ class Server {
           throw new Error("Invalid path: " + config.home)
         }
 
-        // check if the destination already exists => throw error
-        let exists = await fse.pathExists(config.home)
-        if (exists) {
-          throw new Error(`The path ${config.home} already exists. Please remove the folder and retry`)
-        }
+//        // check if the destination already exists => throw error
+//        let exists = await fse.pathExists(config.home)
+//        if (exists) {
+//          throw new Error(`The path ${config.home} already exists. Please remove the folder and retry`)
+//        }
 
-        this.kernel.store.set("new_home", config.home)
+        //this.kernel.store.set("new_home", config.home)
+        this.kernel.store.set("home", config.home)
       }
 
     }
@@ -2015,7 +2019,6 @@ class Server {
 
     home = this.kernel.store.get("home")
     theme = this.kernel.store.get("theme")
-    let new_home = this.kernel.store.get("new_home")
   }
   async startLogging(homedir) {
     console.log(">>>>>>> startLogging", homedir)
@@ -2052,7 +2055,25 @@ class Server {
       }
     }
   }
+  async running(port) {
+    let p = port || DEFAULT_PORT
+    const available = await Util.is_port_available(p)
+    if (available) {
+      return false
+    } else {
+      return true
+    }
+  }
   async start(options) {
+
+//    // ONLY start if not already running
+//    let is_running = await this.running(this.port || DEFAULT_PORT)
+//    if (is_running) {
+//      console.log("pinokiod already running, skip..")
+//      return
+//    }
+//
+
     this.debug = false
     if (options) {
       this.debug = options.debug
@@ -2101,7 +2122,7 @@ class Server {
     // determine port if port is not passed in
 
     if (!this.port) {
-      this.port = 42000
+      this.port = DEFAULT_PORT
 //      let platform = os.platform()
 //      if (platform === 'linux') {
 //        // on linux you are not allowed to listen on ports below 1024

package/server/socket.js

@@ -68,6 +68,12 @@ class Socket {
             }
           } else if (req.emit) {
             this.parent.kernel.shell.emit(req)
+          } else if (req.key && req.id) {
+            console.log( { req })
+            this.parent.kernel.shell.emit({
+              id: req.id,
+              emit: req.key
+            })
           }
         }
 

package/server/views/terminal.ejs

@@ -111,6 +111,7 @@ body.frozen {
 </style>
 <link href="/terminal.css" rel="stylesheet"/>
 <script>
+let shell_id
 document.addEventListener("DOMContentLoaded", async () => {
   <% if (error) { %>
     document.querySelector(".requirements .content").innerHTML = '<div class="loading"><i class="fa-solid fa-circle-exclamation"></i> <%=error%></div>'
@@ -203,6 +204,7 @@ document.addEventListener("DOMContentLoaded", async () => {
             rows: this.term.rows,
           }
         }, async (packet) => {
+          console.log({ packet })
           if (packet.type === 'start') {
             refreshParent(packet)
             reloadMemory()
@@ -234,6 +236,10 @@ document.addEventListener("DOMContentLoaded", async () => {
 //              </div>`
             }
           } else if (packet.type === "stream") {
+            // set the current shell id
+            if (packet.data.id) {
+              shell_id = packet.data.id
+            }
             if (packet.data.raw) {
               this.write(packet.data.raw)
             } else if (packet.data.json) {
@@ -589,6 +595,18 @@ document.addEventListener("DOMContentLoaded", async () => {
         ////term.resize(cols, rows-5);
         //term.resize(cols, rows);
 
+        term.onKey(({ key }) => {
+          console.log({ key })
+          if (this.socket) {
+            if (shell_id) {
+              this.socket.run({
+                key,
+                id: shell_id
+              })
+            }
+          }
+        });
+
         const fitAddon = new FitAddon.FitAddon();
 //        const searchAddon = new SearchAddon.SearchAddon();
 //        const searchAddonBar = new SearchBarAddon.SearchBarAddon({searchAddon});
@@ -606,6 +624,7 @@ document.addEventListener("DOMContentLoaded", async () => {
         fitAddon.fit();
         this.term = term
         this.fit = fitAddon
+
       }
       this.term.focus()
     }