pinokiod 1.3.91 → 1.3.93

package/kernel/api/cloudflare/index.js

@@ -1,18 +1,37 @@
 const { yellow, green, blue  } = require('kleur');
 const QRCode = require('qrcode');
+const path = require('path')
+const Util = require('../../util')
 class C {
   async tunnel (req, ondata, kernel) {
     /*
       {
         "method": "cloundflare.tunnel",
         "params": {
-          "uri": "{{local.url}}"
+          "uri": "{{local.url}}",
+          "passcode": (optional)
         }
       }
 
       => cloudflared tunnel --url http://localhost:8080
     */
-    const message = `cloudflared tunnel --url ${req.params.uri}`
+
+
+    let pipe_uri
+    if (req.params.passcode) {
+      // 1. start a pipe server => needed for authentication
+      const api_path = Util.api_path(req.parent.path, kernel)
+      const pinokio_path = path.resolve(api_path, "pinokio.js")
+      const config  = (await kernel.loader.load(pinokio_path)).resolved
+      pipe_uri = await kernel.pipe.start(req.params.uri, req.parent.path, req.params.passcode, config)
+    } else {
+      // 2. if no passcode required, no need for a pipe server just use the original
+      pipe_uri = req.params.uri
+    }
+
+
+    // 2. run cloudflare tunnel on the proxy
+    const message = `cloudflared tunnel --url ${pipe_uri}`
     let params = {
       id: message,
       message
@@ -65,15 +84,24 @@ class C {
     if (!kernel.memory.local[req.parent.path].$share.cloudflare) {
       kernel.memory.local[req.parent.path].$share.cloudflare = {}
     }
-    kernel.memory.local[req.parent.path].$share.cloudflare[req.params.uri] = cloudflare_url
+    kernel.memory.local[req.parent.path].$share.cloudflare[pipe_uri] = cloudflare_url
 
     return { uri: cloudflare_url }
   }
   async stop (req, ondata, kernel) {
+    // stop the cloudflare shell
     const message = `cloudflared tunnel --url ${req.params.uri}`
     await kernel.shell.kill({
       id: message
     })
+
+    // stop pipe server
+    await kernel.pipe.stop(req.params.uri, req.parent.path)
+
+    // delete the local variable
+    delete kernel.memory.local[req.parent.path].$share.cloudflare[req.params.uri]
+
   }
+
 }
 module.exports = C

package/kernel/api/index.js

@@ -128,6 +128,10 @@ class Api {
     // stop all proxies
     this.stopProxy({ script: requestPath })
 
+    // stop all cloudflare tunnels
+
+    await this.kernel.stopCloudflare({ path: requestPath })
+
     // if there are any pending waiters, delete them
 
     if (this.waiter[requestPath]) {
@@ -538,7 +542,7 @@ class Api {
     // get fully resolved env
     let env = await Environment.get2(request.path, this.kernel)
     // set template
-    this.kernel.template.update(env)
+    this.kernel.template.update({ env })
 
     // render until `{{ }}` pattern does not exist
     // 1. render once

package/kernel/api/local/index.js

@@ -74,6 +74,9 @@ class Local {
         if (val === "true" || val === "1") {
           const c = new Cloudflare()
           req.params.uri = req.params[KEY]
+          if ("PINOKIO_SHARE_PASSCODE" in current_env) {
+            req.params.passcode = current_env.PINOKIO_SHARE_PASSCODE
+          }
           await c.tunnel(req, ondata, kernel)
         }
       }

package/kernel/environment.js

@@ -102,6 +102,48 @@ const ENVS = [{
     "#",
     "##########################################################################",
   ],
+}, {
+  type: ["system", "app"],
+  key: "PINOKIO_SHARE_CLOUDFLARE",
+  val: "false",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_SHARE_CLOUDFLARE",
+    "# Set this variable to share the app publicly via cloudflare tunnel.",
+    "#",
+    "##########################################################################",
+  ]
+}, {
+  type: ["app"],
+  key: "PINOKIO_SHARE_PASSCODE",
+  val: "",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_SHARE_PASSCODE",
+    "#",
+    "# By default, your publicly shared app will be 100% open to anyone",
+    "# with the link via Cloudflare.",
+    "#",
+    "# You can add authorization by protecting it with a passcode.",
+    "# Set this value, and any access to the app will require a pass code input",
+    "#",
+    "##########################################################################",
+  ],
+}, {
+  type: ["system", "app"],
+  key: "PINOKIO_SCRIPT_DEFAULT",
+  val: "true",
+  comment: [
+    "##########################################################################",
+    "#",
+    "# PINOKIO_SCRIPT_DEFAULT",
+    "# If this variable is false, 'default': true menu items in pinokio.js",
+    "# will NOT automatically run",
+    "#",
+    "##########################################################################",
+  ]
 }, {
   type: ["system"],
   key: "PINOKIO_DRIVE",
@@ -194,31 +236,6 @@ const ENVS = [{
     "#",
     "##########################################################################",
   ],
-}, {
-  type: ["system", "app"],
-  key: "PINOKIO_SHARE_CLOUDFLARE",
-  val: "false",
-  comment: [
-    "##########################################################################",
-    "#",
-    "# PINOKIO_SHARE_CLOUDFLARE",
-    "# Set this variable to share the app publicly via cloudflare tunnel.",
-    "#",
-    "##########################################################################",
-  ]
-}, {
-  type: ["system", "app"],
-  key: "PINOKIO_SCRIPT_DEFAULT",
-  val: "true",
-  comment: [
-    "##########################################################################",
-    "#",
-    "# PINOKIO_SCRIPT_DEFAULT",
-    "# If this variable is false, 'default': true menu items in pinokio.js",
-    "# will NOT automatically run",
-    "#",
-    "##########################################################################",
-  ]
 }];
 //const ENV = (homedir) => {
 //  const lines = ENVS.map((e) => {

package/kernel/index.js

@@ -22,6 +22,8 @@ const Environment = require("./environment")
 const Util = require('./util')
 const Config = require("./pinokio.json")
 const Info = require('./info')
+const Pipe = require("../pipe")
+const Cloudflare = require('./api/cloudflare')
 const VARS = {
   pip: {
     install: {
@@ -45,11 +47,33 @@ class Kernel {
     this.exposed = {}
     this.envs = {}
     this.info = new Info(this)
+    this.pipe = new Pipe(this)
+    this.cloudflare = new Cloudflare()
   }
   /*
     kernel.env() => return the system environment
     kernel.env("api/stablediffusion") => returns the full environment object
   */
+  async stopCloudflare(option) {
+    if (option.uri) {
+    } else if (option.path) {
+      let scriptPath = option.path
+      if (this.memory.local[scriptPath] && this.memory.local[scriptPath].$share) {
+        let cf = this.memory.local[scriptPath].$share.cloudflare
+        let uris = Object.keys(cf)
+        for(let uri of uris) {
+          await this.cloudflare.stop({
+            parent: {
+              path: scriptPath
+            },
+            params: { uri }
+          }, (e) => {
+            process.stdout.write(e.raw)
+          }, this)
+        }
+      }
+    }
+  }
   async env(...args) {
     let folderpath
     if (args) {
@@ -114,7 +138,10 @@ class Kernel {
     *  let available_port = await kernel.port()
     *
     **********************************************/
-    return portfinder.getPortPromise()
+    return portfinder.getPortPromise({
+      port: 42000
+    })
+    //return portfinder.getPortPromise()
   }
   path(...args) {
     return path.resolve(this.homedir, ...args)

package/kernel/shell.js

@@ -736,9 +736,7 @@ class Shell {
 # index: ${this.index}
 # cmd: ${this.cmd}
 # timestamp: ${time}
-#
-
-${infoYAML}
+# ${infoYAML.replaceAll("\n", "\n# ")}
 
 `
 
@@ -757,8 +755,11 @@ ${buf}
 
     data.cleaned = `######################################################################
 #
+# group: ${this.group}
+# id: ${this.id}
+# index: ${this.index}
+# cmd: ${this.cmd}
 # timestamp: ${time}
-# ${infoYAML.replaceAll("\n", "\n# ")}
 
 ${cleaned}
 

package/kernel/sysinfo.js

@@ -122,8 +122,7 @@ class Sysinfo {
     }
 
 
-    this.info.env = process.env
-    //this.info.shell_env = vars
+//    this.info.env = process.env
     this.info.shell_env = lines
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "1.3.91",
+  "version": "1.3.93",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -12,6 +12,7 @@
     "7zip-min-win-asar-support": "^1.4.4",
     "async-retry": "^1.3.3",
     "axios": "^1.4.0",
+    "bcrypt": "^5.1.1",
     "clear-module": "^4.1.2",
     "compressing": "^1.10.0",
     "cookie-parser": "^1.4.6",
@@ -33,9 +34,10 @@
     "glob-gitignore": "^1.0.14",
     "handlebars": "^4.7.7",
     "http-proxy": "^1.18.1",
+    "http-proxy-middleware": "^3.0.0",
     "http-terminator": "^3.2.0",
     "isomorphic-git": "^1.23.0",
-    "jimini": "^0.0.5",
+    "jimini": "^0.0.6",
     "jsdom": "^24.0.0",
     "jsonpath-plus": "^7.2.0",
     "key-store": "^1.2.0",

package/pipe/index.js

@@ -0,0 +1,102 @@
+const { createProxyMiddleware } = require('http-proxy-middleware');
+
+const path = require('path')
+const { createHttpTerminator } = require('http-terminator')
+const express = require('express')
+const session = require('express-session');
+const bcrypt = require('bcrypt');
+const cors = require('cors');
+class Pipe {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.terminators = {}
+    this.procs = {}
+  }
+  authenticate (req, res, next) {
+    if (req.session.authenticated) {
+      next();
+    } else {
+      console.log("not authenticated. redirect /pionkio/login")
+      res.redirect('/pinokio/login');
+    }
+  }
+  // a pipe server for creating publicly shareable endpoints
+  async start(url, scriptPath, passcode, config) {
+
+    if (!config) config = {}
+    if (config.icon) {
+    }
+
+
+    let port = await this.kernel.port()
+    let app = express();
+    app.use(cors({ origin: '*' }));
+    app.use(express.urlencoded({ extended: true }));
+    app.set('view engine', 'ejs');
+    app.set("views", path.resolve(__dirname, "views"))
+//    app.use(express.static(path.resolve(__dirname, 'public')));
+    app.use(session({
+      secret: 'oikonip',
+      resave: false,
+      saveUninitialized: true
+    }));
+    app.get('/pinokio/login', (req, res) => {
+      res.render("login", { error: null, ...config })
+    });
+
+    app.post('/pinokio/login', async (req, res) => {
+      
+      const { password } = req.body;
+      
+      //if (await bcrypt.compare(password, hashedPassword)) {
+      if (password === passcode) {
+        req.session.authenticated = true;
+        res.redirect('/');
+      } else {
+        res.status(401).render("login", { error: "Invalid passcode", ...config })
+      }
+    });
+
+    app.get('/pinokio/logout', (req, res) => {
+      req.session.authenticated = false;
+      res.redirect('/login');
+    });
+
+
+    const proxy = createProxyMiddleware({
+      pathFilter: '/',
+      target: url,
+      ws: true
+    })
+
+    app.use('/', this.authenticate, proxy)
+
+
+    await new Promise((resolve, reject) => {
+      console.log("starting pipe server at port", port)
+      let server = app.listen(port, () => {
+        console.log(`Pipe server listening on port ${port}`)
+        resolve()
+      });
+      let terminator = createHttpTerminator({ server });
+      this.terminators[url] = terminator
+    })
+    let pipe_uri = `http://localhost:${port}`
+
+    // original url => pipe url
+    if (!this.procs[scriptPath]) {
+      this.procs[scriptPath] = {}
+    }
+    this.procs[scriptPath][url] = pipe_uri
+    return pipe_uri
+  }
+  async stop(url, scriptPath) {
+    console.log("stop pipe", { scriptPath, url, terminator: this.terminators[url] })
+    if (this.terminators[url]) {
+      await this.terminators[url].terminate()
+      delete this.terminators[url]
+      delete this.procs[scriptPath][url]
+    }
+  }
+}
+module.exports = Pipe

package/pipe/views/login.ejs

@@ -0,0 +1,78 @@
+<html>
+<head>
+<title>Pinokio</title>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1" />
+<style>
+body {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100%;
+  font-family: sans-serif;
+  font-size: 14px;
+  background: rgb(27, 28, 29);
+  color: white;
+}
+main {
+  max-width: 500px;
+  width: 100%;
+  text-align: center;
+  text-transform: lowercase;
+}
+main img {
+  width: 80px;
+  margin-bottom: 20px;
+}
+main form {
+  display: flex;
+}
+main input {
+  flex-grow: 1;
+  padding: 10px;
+  box-sizing: border-box;
+  border: none;
+  /*
+  background: rgba(0,0,0,0.06);
+  */
+  font-size: 14px;
+  border-radius: 0;
+
+}
+main button {
+  color: white;
+  background: royalblue;
+  padding: 10px;
+  box-sizing: border-box;
+  border: none;
+}
+.error {
+  border-left: 3px solid red;
+  color: red;
+  text-align: left;
+  padding: 5px 10px;
+  box-sizing: border-box;
+  font-size: 14px;
+}
+h1 {
+  letter-spacing: -1px;
+  margin-bottom: 20px;
+}
+</style>
+</head>
+<body>
+<main>
+<!--
+  <img src="/pinokio-black.png"/>
+  -->
+  <h1>PINOKIO</h1>
+  <form method="POST" action="/pinokio/login">
+    <input placeholder="enter passcode" type="password" name="password" required>
+    <button type="submit">Login</button>
+  </form>
+  <% if (error) { %>
+    <div class='error'><%=error%></div>
+  <% } %>
+<main>
+</body>
+</html>

package/server/index.js

@@ -173,11 +173,9 @@ class Server {
     })
   }
   async init_env(env_dir_path) {
-    console.log("env_path",env_dir_path)
     let current = this.kernel.path(env_dir_path, "ENVIRONMENT")
       // if environment.json doesn't exist, 
     let exists = await this.exists(current)
-    console.log({ current, exists })
     if (exists) {
       // if ENVIRONMENT already exists, don't do anything
     } else {
@@ -187,11 +185,10 @@ class Server {
       // if _ENVIRONMENT exists, 
       let _environment = this.kernel.path(env_dir_path, "_ENVIRONMENT")
       let _exists = await this.exists(_environment)
-      console.log({ _environment, _exists })
       let content = await Environment.ENV("app")
       if (_exists) {
         let _environmentStr = await fs.promises.readFile(_environment, "utf8")
-        await fs.promises.writeFile(current, _environmentStr + "\n\\n\n" + content)
+        await fs.promises.writeFile(current, _environmentStr + "\n\n\n" + content)
       } else {
         await fs.promises.writeFile(current, content)
       }
@@ -1878,9 +1875,15 @@ class Server {
       // stop proxies
       for(let scriptPath in this.kernel.api.proxies) {
         try {
+          // Turn off local sharing
           await this.kernel.api.stopProxy({
             script: scriptPath
           })
+
+          // Turn off cloudflare sharing
+          await this.kernel.stopCloudflare({
+            path: scriptPath
+          })
         } catch (e) {
         }
       }
@@ -2171,7 +2174,6 @@ class Server {
       }
     })
     this.app.post("/env", async (req, res) => {
-      console.log("req.body", req.body)
       let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
       let updated = req.body.vals
       await Util.update_env(fullpath, updated)
@@ -2206,12 +2208,7 @@ class Server {
       let pathComponents = req.params[0].split("/")
       let filepath = path.resolve(this.kernel.homedir, req.params[0], "ENVIRONMENT")
       let editorpath = "/edit/" + req.params[0] + "/ENVIRONMENT"
-
-      console.log({ pathComponents, filepath, editorpath, })
       const items = await Util.parse_env_detail(filepath)
-
-      console.log(items)
-
       let p = path.resolve(this.kernel.homedir, env_path, "pinokio.js")
       let config  = (await this.kernel.loader.load(p)).resolved
       if (config.icon) {
@@ -2234,16 +2231,13 @@ class Server {
         agent: this.agent,
       })
     })
-    this.app.get("/pre/:name", async (req, res) => {
-      let p = path.resolve(this.kernel.homedir, "api", req.params.name, "pinokio.js")
+    this.app.get("/pre/api/:name", async (req, res) => {
+      let p = path.resolve(this.kernel.homedir, req.params.name, "pinokio.js")
       let config  = (await this.kernel.loader.load(p)).resolved
-      console.log("config", config)
       if (config && config.pre) {
-
         config.pre.forEach((item) => {
           item.icon = `/api/${req.params.name}/${item.icon}?raw=true`
         })
-
         res.render("pre", {
           name: req.params.name,
           theme: this.theme,
@@ -2252,7 +2246,7 @@ class Server {
           items: config.pre
         })
       } else {
-        res.redirect("/env/" + req.params.name)
+        res.redirect("/env/" + req.params.name + "?init=true")
       }
     })
     this.app.get("/initialize/:name", async (req, res) => {
@@ -2262,10 +2256,10 @@ class Server {
         // if pinokio.js exists
         if (config.pre && Array.isArray(config.pre)) {
           // if pre exists, redirect to /pre/:name
-          res.redirect(`/pre/${req.params.name}`)
+          res.redirect(`/pre/api/${req.params.name}`)
         } else {
           // if pre doesn't exist, redirect to /env/:name
-          res.redirect(`/env/${req.params.name}`)
+          res.redirect(`/env/api/${req.params.name}?init=true`)
         }
       } else {
         // if pinokio.js doesn't exist, send to /browser/:name
@@ -2275,9 +2269,7 @@ class Server {
     this.app.get("/share/:name", 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])
-      console.log("filepath", filepath)
       const config = await Util.parse_env(filepath)
-      console.log("config", config)
       const keys = [
         "PINOKIO_SHARE_CLOUDFLARE",
         "PINOKIO_SHARE_LOCAL",
@@ -2294,10 +2286,8 @@ class Server {
       })
       let cloudflare_links = []
       let local_links = []
-      console.log({ app_path, scripts })
       for(let script in this.kernel.memory.local) {
         let mem = this.kernel.memory.local[script]
-        console.log({ script, mem })
         if (mem.$share) {
           if (mem.$share.cloudflare) {
             for(let key in mem.$share.cloudflare) {
@@ -2890,47 +2880,6 @@ class Server {
       });
     })
 
-
-
-//    this.expose_app = express();
-//    this.expose_app.use(cors({
-//      origin: '*'
-//    }));
-//    this.expose_app.use('/', proxy(async (req) => {
-//      console.log("req.url", req.url)
-//      let tokens = req.url.split("/")
-//      console.log({ tokens })
-//      if (tokens.length >=2 ) {
-//        let app = tokens[1]
-//        console.log({ app })
-//        console.log("resolved = ", this.kernel.exposed[app])
-//        return this.kernel.exposed[app]
-//      }
-//    }, {
-////      proxyReqPathResolver: (req) => {
-////        console.log("proxyReqPathResolver", req.url)
-////        let chunks = req.url.split("/")
-////        let transformed
-////        if (chunks.length > 3) {
-////          transformed = "/" + chunks.slice(3).join("/")
-////        } else {
-////          transformed = "/"
-////        }
-////        console.log({ chunks, transformed })
-////        return transformed
-////      }
-//    }))
-//    this.expose_port = await portfinder.getPortPromise({ port: this.port })
-//    console.log("EXPOSE_PORT", this.expose_port)
-//    await new Promise((resolve, reject) => {
-//      this.expose_server = this.expose_app.listen(this.expose_port, () => {
-//        console.log(`Server listening on port ${this.expose_port}`)
-//        resolve()
-//      });
-//      this.exposeTerminator = createHttpTerminator({
-//        server: this.expose_server
-//      });
-//    })
   }
 }
 module.exports = Server

package/server/views/share_editor.ejs

@@ -164,7 +164,7 @@ document.addEventListener("DOMContentLoaded", async () => {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        filepath: "api/" + location.pathname.slice(7) + "/ENVIRONMENT",
+        filepath: "api/" + location.pathname.slice(7),
         vals
       })
     }).then((res) => {
@@ -194,6 +194,7 @@ document.addEventListener("DOMContentLoaded", async () => {
           <li>This will let you share your local Pinokio app to the public internet, which anyone with a URL can access.</li>
           <li>Powered by <a href="https://www.cloudflare.com/products/tunnel/" target="_blank" features="browser">Cloudflare Tunnel</a></li>
           <li>You can manually configure this in through the Configure menu (set PINOKIO_SHARE_CLOUDFLARE to true)</li>
+          <li>You can add <strong>authentication</strong> by adding a passcode (set PINOKIO_SHARE_PASSCODE in the <strong>Configure</strong> tab)</li>
         </ul>
         <% cloudflare_links.forEach((link) => { %>
           <div class='shared'>