pinokiod 2.1.8 → 2.1.10

package/kernel/bin/brew.js

@@ -27,6 +27,8 @@ class Brew {
   }
 
   async installed() {
+    return this.kernel.bin.brew_installed
+    /*
     let e = await this.kernel.bin.exists("homebrew")
 
     let { stdout }= await this.kernel.bin.exec({ message: "xcode-select -p" }, (stream) => { })
@@ -34,6 +36,7 @@ class Brew {
     console.log({ e, e2, stdout })
 
     return e && e2
+    */
   }
 
   uninstall(req, ondata) {

package/kernel/bin/index.js

@@ -350,6 +350,14 @@ class Bin {
 
     console.log("this.installed", this.installed)
 
+    // check brew_installed
+    console.log("checking brew installed")
+    let e = await this.kernel.bin.exists("homebrew")
+    let { stdout }= await this.kernel.bin.exec({ message: "xcode-select -p" }, (stream) => { })
+    let e2 = /(.*Library.*Developer.*CommandLineTools.*|.*Xcode.*Developer.*)/gi.test(stdout)
+    console.log({ e, e2, stdout })
+    this.brew_installed = e && e2
+
 
     this.installed_initialized = true
 

package/kernel/environment.js

@@ -5,15 +5,15 @@ const fs = require('fs')
 const Util = require('./util')
 const platform = os.platform()
 const ENVS = async () => {
-  const primary_port = 80
-  const secondary_port = 42000
-  const available = await portfinder.isAvailablePromise({ host: "0.0.0.0", port: primary_port })
-  let port
-  if (available) {
-    port = primary_port
-  } else {
-    port = secondary_port 
-  }
+//  const primary_port = 80
+//  const secondary_port = 42000
+//  const available = await portfinder.isAvailablePromise({ host: "0.0.0.0", port: primary_port })
+//  let port
+//  if (available) {
+//    port = primary_port
+//  } else {
+//    port = secondary_port 
+//  }
   return [{
     type: ["system"],
     key: "HOMEBREW_CACHE",
@@ -173,20 +173,20 @@ const ENVS = async () => {
       "#",
       "##########################################################################",
     ],
-  }, {
-    type: ["system"],
-    key: "PINOKIO_PORT",
-    val: `${port}`,
-    comment: [
-      "##########################################################################",
-      "#",
-      "# PINOKIO_PORT",
-      "#",
-      "# The server port Pinokio will use. By default it's 80 but you can",
-      "# Change it to anything else",
-      "#",
-      "##########################################################################",
-    ],
+//  }, {
+//    type: ["system"],
+//    key: "PINOKIO_PORT",
+//    val: `${port}`,
+//    comment: [
+//      "##########################################################################",
+//      "#",
+//      "# PINOKIO_PORT",
+//      "#",
+//      "# The server port Pinokio will use. By default it's 80 but you can",
+//      "# Change it to anything else",
+//      "#",
+//      "##########################################################################",
+//    ],
   }, {
     type: ["system", "app"],
     key: "GRADIO_TEMP_DIR",
@@ -281,24 +281,42 @@ const ENVS = async () => {
 //}
 
 // type := system|app
-const ENV = async (type) => {
+const ENV = async (type, homedir) => {
   const envs = await ENVS()
-  return envs.filter((e) => {
+  let filtered_envs = envs.filter((e) => {
     return e.type.includes(type)
-  }).map((e) => {
+  })
+
+  let lines = []
+  for(let e of filtered_envs) {
     let comment = ""
     if (e.comment && Array.isArray(e.comment)) {
       comment = "\n" + e.comment.join("\n") + "\n"
     }
 
-    let kv
+    let val
     if (typeof e.val === "function") {
-      kv = `${e.key}=${e.val(type)}`
+      val = e.val(type)
     } else {
-      kv = `${e.key}=${e.val}`
+      val = e.val
+    }
+
+    // if app environment,
+    //  if e.key exists on system env, use that
+    //  if e.key does NOT exist on system env, 
+    if (type === 'app') {
+      let system_env = await get(homedir)
+      if (e.key in system_env) {
+        console.log(`original ${e.key}=${val}`)
+        val = system_env[e.key]
+        console.log(`inherited from system_env: ${e.key}=${val}`)
+      }
     }
-    return comment + kv
-  }).join("\n")
+
+    let kv = `${e.key}=${val}`
+    lines.push(comment+kv)
+  }
+  return lines.join("\n")
 }
 const init_folders = async (homedir) => {
   const current_env = await get(homedir)

package/kernel/index.js

@@ -296,7 +296,7 @@ class Kernel {
         // if it doesn't exist, write to ~/pinokio/ENVIRONMENT
         let e = await this.exists(this.homedir, "ENVIRONMENT")
         if (!e) {
-          let str = await Environment.ENV("system")
+          let str = await Environment.ENV("system", this.homedir)
           await fs.promises.writeFile(path.resolve(this.homedir, "ENVIRONMENT"), str)
         }
         // 2. mkdir all the folders if not already created

package/package.json

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

package/server/index.js

@@ -28,6 +28,10 @@ const multer = require('multer');
 
 const ejs = require('ejs');
 
+const ex = fn => (req, res, next) => {
+  Promise.resolve(fn(req, res, next)).catch(next);
+};
+
 
 
 
@@ -184,7 +188,7 @@ class Server {
       // if _ENVIRONMENT exists, 
       let _environment = this.kernel.path(env_dir_path, "_ENVIRONMENT")
       let _exists = await this.exists(_environment)
-      let content = await Environment.ENV("app")
+      let content = await Environment.ENV("app", this.kernel.homedir)
       if (_exists) {
         let _environmentStr = await fs.promises.readFile(_environment, "utf8")
         await fs.promises.writeFile(current, _environmentStr + "\n\n\n" + content)
@@ -388,7 +392,7 @@ class Server {
       // if environment.json doesn't exist, 
       let exists = await this.exists(filepath)
       if (!exists) {
-        let content = await Environment.ENV("app")
+        let content = await Environment.ENV("app", this.kernel.homedir)
         await fs.promises.writeFile(filepath, content)
       }
     }
@@ -455,7 +459,9 @@ class Server {
         install_required = false
         for(let i=0; i<requirements.length; i++) {
           let r = requirements[i]
+          console.log("r", r)
           let installed = await this.installed(r)
+          console.log("installed", installed)
           requirements[i].installed = installed
           if (!installed) {
             install_required = true
@@ -826,54 +832,6 @@ class Server {
 
 
         let mem = this.getMemory(filepath)
-//        let localMem = this.kernel.memory.local[filepath]
-//        let globalMem = this.kernel.memory.global[filepath]
-//
-//        let mem = []
-//        let localhosts = ["localhost", "127.0.0.1", "0.0.0.0"]
-//        for(let key in localMem) {
-//          let val = localMem[key]
-//          // check for localhost url
-//          let localhost = false
-//          let tunnel
-//          try {
-//            let url = new URL(val)
-//            if (localhosts.includes(url.hostname)) {
-//              localhost = true
-//              if (this.tunnels[val]) {
-//                tunnel = this.tunnels[val].url
-//              }
-//            }
-//          } catch (e) { }
-//          mem.push({
-//            type: "local",
-//            key,
-//            val,
-//            tunnel,
-//            localhost,
-//          })
-//        }
-//        for(let key in globalMem) {
-//          let val = globalMem[key]
-//          let localhost = false
-//          let tunnel
-//          try {
-//            let url = new URL(val)
-//            if (localhosts.includes(url.hostname)) {
-//              localhost = true
-//              if (this.tunnels[val]) {
-//                tunnel = this.tunnels[val].url
-//              }
-//            }
-//          } catch (e) { }
-//          mem.push({
-//            type: "global",
-//            key,
-//            val,
-//            tunnel,
-//            localhost,
-//          })
-//        }
         let edu = new URL("http://localhost" + req.originalUrl)
         edu.searchParams.set("mode", "source")
         let editorUrl = edu.pathname + edu.search
@@ -1907,6 +1865,7 @@ class Server {
       const primary_port = 80
       const secondary_port = 42000
       const available = await portfinder.isAvailablePromise({ host: "0.0.0.0", port: primary_port })
+      console.log("check available", { primary_port, available })
       if (available) {
         this.port = primary_port
       } else {
@@ -1923,14 +1882,14 @@ class Server {
     if (this.kernel.homedir) {
       let ex = await this.kernel.exists(this.kernel.homedir, "ENVIRONMENT")
       if (!ex) {
-        let str = await Environment.ENV("system")
+        let str = await Environment.ENV("system", this.kernel.homedir)
         await fs.promises.writeFile(path.resolve(this.homedir, "ENVIRONMENT"), str)
       }
 
-      let env = await Environment.get(this.kernel.homedir)
-      if (env && env.PINOKIO_PORT) {
-        this.port = env.PINOKIO_PORT
-      }
+//      let env = await Environment.get(this.kernel.homedir)
+//      if (env && env.PINOKIO_PORT) {
+//        this.port = env.PINOKIO_PORT
+//      }
     }
 
     console.log("using port", this.port)
@@ -2009,7 +1968,7 @@ class Server {
 
     //let home = this.kernel.homedir
     let home = this.kernel.store.get("home")
-    this.app.get("/", async (req, res) => {
+    this.app.get("/", ex(async (req, res) => {
       if (req.query.mode !== "settings" && !home) {
         res.redirect("/?mode=settings")
         return
@@ -2136,9 +2095,9 @@ class Server {
 //          agent: this.agent,
 //        })
 //      }
-    })
+    }))
 
-    this.app.post("/unpublish", async (req, res) => {
+    this.app.post("/unpublish", ex(async (req, res) => {
       /*
         req.body := {
           type: "local"|"cloudflare"
@@ -2163,8 +2122,8 @@ class Server {
       } else {
         res.json({ error: "type must be 'local' or 'cloudflare'" })
       }
-    })
-    this.app.post("/publish", async (req, res) => {
+    }))
+    this.app.post("/publish", ex(async (req, res) => {
       /*
         req.body := {
           type: "local"|"cloudflare"
@@ -2199,14 +2158,14 @@ class Server {
       } else {
         res.json({ error: "type must be 'local' or 'cloudflare'" })
       }
-    })
-    this.app.post("/env", async (req, res) => {
+    }))
+    this.app.post("/env", ex(async (req, res) => {
       let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
       let updated = req.body.vals
       await Util.update_env(fullpath, updated)
       res.json({})
-    })
-    this.app.get("/env", async (req, res) => {
+    }))
+    this.app.get("/env", ex(async (req, res) => {
       let env_path = path.resolve(this.kernel.homedir)
       await this.init_env(env_path)
 
@@ -2227,8 +2186,8 @@ class Server {
         filepath,
         agent: this.agent,
       })
-    })
-    this.app.get("/env/*", async (req, res) => {
+    }))
+    this.app.get("/env/*", ex(async (req, res) => {
 
       let env_path = req.params[0]
       await this.init_env(env_path)
@@ -2259,8 +2218,8 @@ class Server {
         filepath,
         agent: this.agent,
       })
-    })
-    this.app.get("/pre/api/:name", async (req, res) => {
+    }))
+    this.app.get("/pre/api/:name", ex(async (req, res) => {
       let p = path.resolve(this.kernel.homedir, "api", req.params.name, "pinokio.js")
       let config  = (await this.kernel.loader.load(p)).resolved
       if (config && config.pre) {
@@ -2277,8 +2236,8 @@ class Server {
       } else {
         res.redirect("/env/" + req.params.name + "?init=true")
       }
-    })
-    this.app.get("/initialize/:name", async (req, res) => {
+    }))
+    this.app.get("/initialize/:name", ex(async (req, res) => {
       let p = path.resolve(this.kernel.homedir, "api", req.params.name, "pinokio.js")
       let config  = (await this.kernel.loader.load(p)).resolved
       if (config) {
@@ -2294,8 +2253,8 @@ class Server {
         // if pinokio.js doesn't exist, send to /browser/:name
         res.redirect(`/pinokio/browser/${req.params.name}`)
       }
-    })
-    this.app.get("/share/:name", async (req, res) => {
+    }))
+    this.app.get("/share/:name", ex(async (req, res) => {
       let filepath = path.resolve(this.kernel.homedir, "api", req.params.name, "ENVIRONMENT")
       //let filepath = path.resolve(this.kernel.homedir, req.params[0])
       const config = await Util.parse_env(filepath)
@@ -2351,8 +2310,8 @@ class Server {
         filepath,
         agent: this.agent,
       })
-    })
-    this.app.get("/edit/*", async (req, res) => {
+    }))
+    this.app.get("/edit/*", ex(async (req, res) => {
       let pathComponents = req.params[0].split("/")
       let filepath = path.resolve(this.kernel.homedir, req.params[0])
       const content = await fs.promises.readFile(filepath, "utf8")
@@ -2363,13 +2322,13 @@ class Server {
         content,
         agent: this.agent,
       })
-    })
-    this.app.get("/script/:name", (req, res) => {
+    }))
+    this.app.get("/script/:name", ex((req, res) => {
       if (req.params.name === "start") {
         res.json(this.startScripts)
       }
-    })
-    this.app.get("/raw/*", (req, res) => {
+    }))
+    this.app.get("/raw/*", ex((req, res) => {
       let pathComponents = req.params[0].split("/")
       let filepath = this.kernel.path("api", ...pathComponents)
       try {
@@ -2382,8 +2341,8 @@ class Server {
       } catch (e) {
         res.status(404).send(e.message);
       }
-    })
-    this.app.get("/_api/*", async (req, res) => {
+    }))
+    this.app.get("/_api/*", ex(async (req, res) => {
       let pathComponents = req.params[0].split("/")
       req.query.mode = "source"
       try {
@@ -2391,16 +2350,16 @@ class Server {
       } catch (e) {
         res.status(404).send(e.message)
       }
-    })
-    this.app.get("/api/*", async (req, res) => {
+    }))
+    this.app.get("/api/*", ex(async (req, res) => {
       let pathComponents = req.params[0].split("/")
       try {
         await this.render(req, res, pathComponents)
       } catch (e) {
         res.status(404).send(e.message)
       }
-    })
-    this.app.get("/pinokio/sidebar/:name", async (req, res) => {
+    }))
+    this.app.get("/pinokio/sidebar/:name", ex(async (req, res) => {
       let name = req.params.name
       let app_path = this.kernel.path("api", name, "pinokio.js")
       let rawpath = "/api/" + name
@@ -2453,12 +2412,12 @@ class Server {
       })
       */
 
-    })
-    this.app.get("/pinokio/memory", (req, res) => {
+    }))
+    this.app.get("/pinokio/memory", ex((req, res) => {
       let filepath = req.query.filepath
       let mem = this.getMemory(filepath)
       res.json(mem)
-    })
+    }))
 //    this.app.post("/pinokio/tunnel", async (req, res) => {
 //      let port
 //      let local_host
@@ -2510,11 +2469,11 @@ class Server {
 //        res.json({ error: e.message })
 //      }
 //    })
-    this.app.post("/pinokio/tabs", async (req, res) => {
+    this.app.post("/pinokio/tabs", ex(async (req, res) => {
       this.tabs[req.body.name] = req.body.tabs
       res.json({ success: true })
-    })
-    this.app.get("/pinokio/browser", async (req, res) => {
+    }))
+    this.app.get("/pinokio/browser", ex(async (req, res) => {
       if (req.query && req.query.uri) {
         let uri = req.query.uri
         let p = this.kernel.api.resolveBrowserPath(uri)
@@ -2522,19 +2481,19 @@ class Server {
       } else {
         res.redirect("/")
       }
-    })
-    this.app.get("/pinokio/launch/:name", async (req, res) => {
+    }))
+    this.app.get("/pinokio/launch/:name", ex(async (req, res) => {
       this.chrome(req, res, "launch")
-    })
-    this.app.get("/pinokio/browser/:name/browse", async (req, res) => {
+    }))
+    this.app.get("/pinokio/browser/:name/browse", ex(async (req, res) => {
       console.log("browse mode")
       this.chrome(req, res, "browse")
-    })
-    this.app.get("/pinokio/browser/:name", async (req, res) => {
+    }))
+    this.app.get("/pinokio/browser/:name", ex(async (req, res) => {
       console.log("run mode")
       this.chrome(req, res, "run")
-    })
-    this.app.post("/pinokio/delete", async (req, res) => {
+    }))
+    this.app.post("/pinokio/delete", ex(async (req, res) => {
       try {
         if (req.body.type === 'bin') {
           let folderPath = this.kernel.path("bin")
@@ -2565,7 +2524,7 @@ class Server {
       } catch(err) {
         res.json({ error: err.stack })
       }
-    })
+    }))
 //    this.app.get("/pinokio/shell_state", (req, res) => {
 //      let states = this.kernel.shell.shells.map((s) => {
 //        return {
@@ -2592,12 +2551,12 @@ class Server {
 //        gpus: this.kernel.gpus
 //      }
 //    })
-    this.app.get("/pinokio/logs.zip", (req, res) => {
+    this.app.get("/pinokio/logs.zip", ex((req, res) => {
       let zipPath = this.kernel.path("logs.zip")
       console.log("sendFile", zipPath)
       res.download(zipPath)
-    })
-    this.app.post("/pinokio/log", async (req, res) => {
+    }))
+    this.app.post("/pinokio/log", ex(async (req, res) => {
 
 
       let states = this.kernel.shell.shells.map((s) => {
@@ -2641,21 +2600,21 @@ class Server {
       let zipPath = this.kernel.path("logs.zip")
       await compressing.zip.compressDir(folder, zipPath)
       res.json({ success: true })
-    })
-    this.app.get("/pinokio/port", async (req, res) => {
+    }))
+    this.app.get("/pinokio/port", ex(async (req, res) => {
       let port = await this.kernel.port()
       res.json({ result: port })
-    })
-    this.app.get("/pinokio/download", (req, res) => {
+    }))
+    this.app.get("/pinokio/download", ex((req, res) => {
       let queryStr = new URLSearchParams(req.query).toString()
       res.redirect("/?mode=download&" + queryStr)
-    })
-    this.app.post("/pinokio/install", (req, res) => {
+    }))
+    this.app.post("/pinokio/install", ex((req, res) => {
       req.session.requirements = req.body.requirements
       req.session.callback = req.body.callback
       res.redirect("/pinokio/install")
-    })
-    this.app.get("/pinokio/install", (req, res) => {
+    }))
+    this.app.get("/pinokio/install", ex((req, res) => {
       let requirements = req.session.requirements
       let callback = req.session.callback
       req.session.requirements = null
@@ -2670,8 +2629,8 @@ class Server {
         requirements,
         callback
       })
-    })
-    this.app.get("/pinokio", (req, res) => {
+    }))
+    this.app.get("/pinokio", ex((req, res) => {
       // parse the uri & path
       let {uri, ...query} = req.query
       let querystring = new URLSearchParams(query).toString()
@@ -2680,7 +2639,7 @@ class Server {
         webpath = webpath + "?" + querystring
       }
       res.redirect(webpath)
-    })
+    }))
     /*
       SYNTAX
       fs.uri(<bin|api>, path)
@@ -2693,7 +2652,7 @@ class Server {
       1. Git URI: http://localhost:4200/pinokio/fs?drive=api&path=https://github.com/cocktailpeanut/llamacpp.pinokio.git/icon.png
       2. Local path: http://localhost:4200/pinokio/fs?drive=api&path=test/icon.png
     */
-    this.app.get("/pinokio/fs", (req, res) => {
+    this.app.get("/pinokio/fs", ex((req, res) => {
       // serve reaw files
       if (req.query && req.query.drive && req.query.path) {
         let p
@@ -2715,8 +2674,8 @@ class Server {
       } else {
         res.status(404).send("Missing attribute: path")
       }
-    })
-    this.app.post("/pinokio/fs", this.upload.any(), async (req, res) => {
+    }))
+    this.app.post("/pinokio/fs", this.upload.any(), ex(async (req, res) => {
       /*
         Packet format:
           types: <argument types>
@@ -2872,21 +2831,21 @@ class Server {
         res.json({ error: "Required attributes: path, method, types" })
       }
 
-    })
-    this.app.get("/pinokio/requirements_ready", (req, res) => {
+    }))
+    this.app.get("/pinokio/requirements_ready", ex((req, res) => {
 
       let requirements_pending = !this.kernel.bin.installed_initialized
       console.log({ requirements_pending })
       res.json({ requirements_pending })
-    })
-    this.app.get("/check", (req, res) => {
+    }))
+    this.app.get("/check", ex((req, res) => {
       res.json({ success: true })
-    })
-    this.app.post("/restart", async (req, res) => {
+    }))
+    this.app.post("/restart", ex(async (req, res) => {
       console.log("post /restart")
-      this.start(this.debug)
-    })
-    this.app.post("/config", async (req, res) => {
+      this.start({ debug: this.debug, browser: this.browser })
+    }))
+    this.app.post("/config", ex(async (req, res) => {
       console.log("/config", { body: req.body })
       try {
         await this.setConfig(req.body)
@@ -2896,7 +2855,19 @@ class Server {
       }
 
       // update homedir
-    })
+    }))
+
+    this.app.use((err, req, res, next) => {
+      process.stdout.write("\r\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+      process.stdout.write("\r\n> ERROR\r\n")
+      process.stdout.write(err.stack)
+      process.stdout.write("\r\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n")
+      res.status(500).render("500", {
+        stack: err.stack
+      })
+    });
+
+
     // install
     this.server = httpserver.createServer(this.app);
     this.socket = new Socket(this)

package/server/views/500.ejs

@@ -0,0 +1,50 @@
+<html>
+<head>
+<style>
+body {
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  background: royalblue;
+  color: white;
+  padding: 50px;
+  box-sizing: border-box;
+  font-family: sans-serif;
+  font-size: 14px;
+}
+h1 {
+  font-size: 40px;
+  text-transform: uppercase;
+}
+pre {
+  width: 100%;
+}
+footer {
+  border-left: 4px solid white;
+  padding: 10px 20px;
+  margin-top: 50px;
+}
+footer ol {
+  padding-inline-start: 20px;
+  margin: 0;
+  padding-top: 10px;
+}
+footer a {
+  color: white;
+  font-weight: bold;
+}
+</style>
+</head>
+<body>
+<h1>Error</h1>
+<pre><%=stack%></pre>
+<footer>
+  <div>You may want to try:</div>
+  <ol>
+    <li>Update to the latest version of Pinokio: <a href="https://program.pinokio.computer/#/?id=install" target="_blank">https://program.pinokio.computer/#/?id=install</a></li>
+    <li>Try troubleshooting: <a href="/?mode=settings#troubleshoot">Troubleshoot</a></li>
+    <li>Ask in community Discord: <a href="https://discord.gg/TQdNwadtE4" target="_blank">Discord</a></li>
+  </ol>
+</footer>
+</body>
+</html>

package/server/views/index.ejs

@@ -154,7 +154,7 @@ body.dark .browser-options-row {
 <nav class='error-message'>
   <div><%=error%></div>
   <div class='flexible'></div>
-  <a class='btn' target="_blank" href="https://docs.pinokio.computer/download/">Download</a>
+  <a class='btn' target="_blank" href="https://program.pinokio.computer/#/?id=install">Download</a>
 </nav>
 <% } %>
 <!--

package/server/views/settings.ejs

@@ -296,7 +296,7 @@ hr {
   </div>
   <% if (locals.bin) { %>
     <hr/>
-    <div class='troubleshoot'>
+    <div id='troubleshoot' class='troubleshoot'>
       <h1>Troubleshoot</h1>
       <br>
       <br>