pinokiod 3.8.26 → 3.8.28

package/kernel/caddy.js

@@ -4,34 +4,16 @@ class Caddy {
   constructor(kernel) {
     this.kernel = kernel
   }
-  async update() {
-    this.mapping = {}
-    let payload = await this.payload()
-    console.log("Make request to caddy", JSON.stringify(payload, null, 2))
-    let response = await axios.post('http://127.0.0.1:2019/load', payload, {
-      headers: { 'Content-Type': 'application/json' }
-    }).catch((e) => {
-      console.log("EEEEEEEEEEEEE", e)
-    })
-    console.log("Caddy Response", { response })
-  }
-  async procs (payload) {
-    console.log("####### procs", payload)
-    let list = this.kernel.processes.list
-    if (!list) {
-      list = await this.kernel.processes.refresh()
-    }
-    for(let item of list) {
-      let url = `${item.port}.localhost`
-      this.mapping[item.ip] = url
+  peers_home (payload) {
+    let peers = this.kernel.peer.get()
+    for(let ip of peers) {
+      let account = this.kernel.peer.account(ip)
       payload.apps.http.servers.main.routes.push({
-        "match": [{
-          "host": [url],
-        }],
+        "match": [{ "host": [`pinokio.${account}.localhost`] }],
         "handle": [
           {
             "handler": "reverse_proxy",
-            "upstreams": [{ "dial": item.ip }]
+            "upstreams": [{ "dial": `${ip}:42000` }]
           },
           {
             "handler": "headers",
@@ -49,6 +31,136 @@ class Caddy {
     }
     return payload
   }
+  home () {
+    return {
+      "apps": {
+        "http": {
+          "servers": {
+            "main": {
+              "listen": [":443"],
+              "routes": [
+                {
+                  "match": [{ "method": ["OPTIONS"] }],
+                  "handle": [
+                    {
+                      "handler": "headers",
+                      "response": {
+                        "set": {
+                          "Access-Control-Allow-Origin": ["*"],
+                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                          "Access-Control-Allow-Headers": ["*"],
+                          "Vary": ["Origin"]
+                        }
+                      }
+                    },
+                    {
+                      "handler": "static_response",
+                      "status_code": 204
+                    }
+                  ]
+                },
+                {
+                  "match": [{ "host": [`pinokio.localhost`] }],
+                  "handle": [
+                    {
+                      "handler": "reverse_proxy",
+                      "upstreams": [{ "dial": "127.0.0.1:42000" }]
+                    },
+                    {
+                      "handler": "headers",
+                      "response": {
+                        "set": {
+                          "Access-Control-Allow-Origin": ["*"],
+                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                          "Access-Control-Allow-Headers": ["*"],
+                          "Vary": ["Origin"]
+                        }
+                      }
+                    }
+                  ]
+                },
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+  peers_locals(payload) {
+    let peers = this.kernel.peer.get()
+    for(let ip of peers) {
+      let account = this.kernel.peer.account(ip)
+      let local = this.kernel.peer.local(ip)
+      // construct Caddy update payload
+      console.log({ local })
+      for(let script_path in local) {
+        let local_variables = local[script_path]
+        console.log({ local_variables })
+        for(let key in local_variables) {
+          let val = local_variables[key]
+          if (val.startsWith("http")) {
+            val = val.replace(/https?:\/\//, '')
+
+            // replace 127,0.0.1 or localhost with the 192.168 address
+            val = val.replace(/localhost|127\.0\.0\.1/g, ip)
+            let api_path = path.resolve(this.kernel.peer.homedir(ip), "api")
+            let rel_path = path.relative(api_path, script_path)
+            let name = rel_path.split(path.sep)[0]
+            console.log({ api_path, rel_path, name, val })
+            if (key === "url") {
+              let url = `${name}.${account}.localhost`.toLowerCase()
+              this.mapping[val] = url
+              payload.apps.http.servers.main.routes.push({
+                "match": [{
+                  "host": [url]
+                }],
+                "handle": [
+                  {
+                    "handler": "reverse_proxy",
+                    "upstreams": [{ "dial": val }]
+                  },
+                  {
+                    "handler": "headers",
+                    "response": {
+                      "set": {
+                        "Access-Control-Allow-Origin": ["*"],
+                        "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                        "Access-Control-Allow-Headers": ["*"],
+                        "Vary": ["Origin"]
+                      }
+                    }
+                  }
+                ]
+              })
+            }
+            payload.apps.http.servers.main.routes.push({
+              "match": [{
+                "host": [`${key}.${name}${account}.localhost`.toLowerCase()],
+              }],
+              "handle": [
+                {
+                  "handler": "reverse_proxy",
+                  "upstreams": [{ "dial": val }]
+                },
+                {
+                  "handler": "headers",
+                  "response": {
+                    "set": {
+                      "Access-Control-Allow-Origin": ["*"],
+                      "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                      "Access-Control-Allow-Headers": ["*"],
+                      "Vary": ["Origin"]
+                    }
+                  }
+                }
+              ]
+            })
+          }
+        }
+      }
+    }
+    return payload
+  }
   locals (payload) {
     // construct Caddy update payload
     let local = this.kernel.memory.local;
@@ -70,13 +182,8 @@ class Caddy {
             payload.apps.http.servers.main.routes.push({
               "match": [{
                 "host": [url]
-                //"path": [`/local/${key}/${uri}/*`]
               }],
               "handle": [
-                //{
-                //  "handler": "rewrite",
-                //  "uri": "/"
-                //},
                 {
                   "handler": "reverse_proxy",
                   "upstreams": [{ "dial": val }]
@@ -98,13 +205,8 @@ class Caddy {
           payload.apps.http.servers.main.routes.push({
             "match": [{
               "host": [`${key}.${name}.localhost`.toLowerCase()],
-              //"path": [`/local/${key}/${uri}/*`]
             }],
             "handle": [
-              //{
-              //  "handler": "rewrite",
-              //  "uri": "/"
-              //},
               {
                 "handler": "reverse_proxy",
                 "upstreams": [{ "dial": val }]
@@ -127,66 +229,113 @@ class Caddy {
     }
     return payload
   }
-  home () {
-    return {
-      "apps": {
-        "http": {
-          "servers": {
-            "main": {
-              //"listen": ["127.0.0.1:443"],
-              "listen": [":443"],
-              "routes": [
-                {
-                  "match": [{ "method": ["OPTIONS"] }],
-                  "handle": [
-                    {
-                      "handler": "headers",
-                      "response": {
-                        "set": {
-                          "Access-Control-Allow-Origin": ["*"],
-                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                          "Access-Control-Allow-Headers": ["*"],
-                          "Vary": ["Origin"]
-                        }
-                      }
-                    },
-                    {
-                      "handler": "static_response",
-                      "status_code": 204
-                    }
-                  ]
-                },
-                {
-                  "match": [{ "host": ["pinokio.localhost"] }],
-                  "handle": [
-                    {
-                      "handler": "reverse_proxy",
-                      "upstreams": [{ "dial": "127.0.0.1:42000" }]
-                    },
-                    {
-                      "handler": "headers",
-                      "response": {
-                        "set": {
-                          "Access-Control-Allow-Origin": ["*"],
-                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                          "Access-Control-Allow-Headers": ["*"],
-                          "Vary": ["Origin"]
-                        }
-                      }
-                    }
-                  ]
-                },
-              ]
+  async peers_procs (payload) {
+    console.log("####### procs", payload)
+    let list = this.kernel.peer.get()
+    for(let ip of list) {
+      let account = this.kernel.peer.account(ip)
+
+      // caddy_mapping := { IP => HTTPS_DOMAIN }
+      let caddy_mapping = this.kernel.peer.caddy(ip)
+      for(let app_ip in caddy_mapping) {
+        let https_domain = caddy_mapping[app_ip]
+        let remote_app_ip = app_ip.replace(/localhost|127\.0\.0\.1/g, ip)
+        // https_domain <port>.localhost
+        let url  = https_domain.replace(/\.localhost$/, '') + `${account}.localhost`
+        this.mapping[remote_app_ip] = url
+        payload.apps.http.servers.main.routes.push({
+          "match": [{
+            "host": [url],
+          }],
+          "handle": [
+            {
+              "handler": "reverse_proxy",
+              "upstreams": [{ "dial": remote_app_ip }]
+            },
+            {
+              "handler": "headers",
+              "response": {
+                "set": {
+                  "Access-Control-Allow-Origin": ["*"],
+                  "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                  "Access-Control-Allow-Headers": ["*"],
+                  "Vary": ["Origin"]
+                }
+              }
             }
-          }
-        }
+          ]
+        })
       }
     }
+    return payload
+  }
+  async procs (payload) {
+    console.log("####### procs", payload)
+    let list = this.kernel.processes.list
+    if (!list) {
+      list = await this.kernel.processes.refresh()
+    }
+    for(let item of list) {
+      let url = `${item.port}.localhost`
+      this.mapping[item.ip] = url
+      payload.apps.http.servers.main.routes.push({
+        "match": [{
+          "host": [url],
+        }],
+        "handle": [
+          {
+            "handler": "reverse_proxy",
+            "upstreams": [{ "dial": item.ip }]
+          },
+          {
+            "handler": "headers",
+            "response": {
+              "set": {
+                "Access-Control-Allow-Origin": ["*"],
+                "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                "Access-Control-Allow-Headers": ["*"],
+                "Vary": ["Origin"]
+              }
+            }
+          }
+        ]
+      })
+    }
+    return payload
+  }
+  peers(payload) {
+    let peers = this.kernel.peer.get()
+    for(let peer of peers) {
+      let account = peer.username
+    }
+  }
+  async update() {
+    this.mapping = {}
+    let payload = await this.payload()
+    console.log("Make request to caddy", JSON.stringify(payload, null, 2))
+    let response = await axios.post('http://127.0.0.1:2019/load', payload, {
+      headers: { 'Content-Type': 'application/json' }
+    }).catch((e) => {
+      console.log("EEEEEEEEEEEEE", e)
+    })
+    console.log("Caddy Response", { response })
   }
   async payload () {
+
+    // localhost home
     let payload = this.home()
+    // peers home
+    let peers = this.kernel.peer.get()
+    payload = this.peers_home(payload)
+
+    // localhost local variables
     payload = this.locals(payload)
+    // peers local variables
+    payload = this.peers_locals(payload)
+
     payload = await this.procs(payload)
+    payload = this.peers_procs(payload)
+
     return payload
   }
 }

package/kernel/index.js

@@ -32,6 +32,7 @@ const Store = require('./store')
 const Proto = require('./prototype')
 const Caddy = require("./caddy")
 const Procs = require('./procs')
+const Peer = require('./peer')
 const VARS = {
   pip: {
     install: {
@@ -86,6 +87,8 @@ class Kernel {
     this.kv = new KV(this)
     this.cloudflare = new Cloudflare()
     this.shellpath = shellPath.sync()
+
+    this.peer = new Peer()
   }
   /*
     kernel.env() => return the system environment

package/kernel/peer.js

@@ -0,0 +1,65 @@
+const dgram = require('dgram');
+const axios = require('axios');
+const os = require('os')
+class PeerDiscovery {
+  constructor(port = 41234, message = 'ping', interval = 1000) {
+    this.port = port;
+    this.message = Buffer.from(message);
+    this.interval = interval;
+    this.socket = dgram.createSocket('udp4');
+    this.peers = new Set();
+    this.current_account = os.userInfo()
+//    this.start();
+  }
+  account(ip) {
+    return this.data[ip].account
+  }
+  home(ip) {
+    return this.data[ip].homedir
+  }
+  caddy(ip) {
+    return this.data[ip].caddy
+  }
+  local(ip) {
+    return this.data[ip].memory.local
+  }
+  global(ip) {
+    return this.data[ip].memory.global
+  }
+  start() {
+    // Listen for incoming pings
+    this.data = {}
+    this.socket.on('message', (msg, rinfo) => {
+      const ip = rinfo.address;
+      if (msg.toString() === this.message.toString() && this._isLocalLAN(ip)) {
+        if (!this.peers.has(ip)) {
+          this.peers.add(ip);
+          axios.get(`http://${ip}:42000/pinokio/mem`).then((res) => {
+            this.data[ip] = res.data
+          })
+          console.log(`Discovered peer: ${ip}`);
+        }
+      }
+    });
+
+    // Enable broadcast
+    this.socket.bind(this.port, () => {
+      this.socket.setBroadcast(true);
+
+      // Send broadcast pings every interval
+      setInterval(() => {
+        this.socket.send(this.message, 0, this.message.length, this.port, '255.255.255.255');
+      }, this.interval);
+    });
+  }
+
+  get() {
+    return Array.from(this.peers);
+  }
+
+  _isLocalLAN(ip) {
+    return ip.startsWith('192.168.');
+  }
+}
+
+module.exports = PeerDiscovery;

package/package.json

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

package/server/index.js

@@ -2668,6 +2668,8 @@ class Server {
       })
       await this.kernel.caddy.update()
 
+      let peers = this.kernel.peer.get()
+
       let live_proxies = this.kernel.api.proxies["/proxy"]
       if (!live_proxies) live_proxies = []
       let proxies = []
@@ -2745,6 +2747,7 @@ class Server {
         }
       }
       res.render("proxy", {
+        peers,
         list,
         agent: this.agent,
         theme: this.theme,
@@ -3274,6 +3277,14 @@ class Server {
       */
 
     }))
+    this.app.get("/pinokio/mem", ex((req, res) => {
+      res.json({
+        homedir: this.kernel.homedir,
+        account: this.kernel.peer.current_account,
+        caddy: this.kernel.caddy.mapping, // mapping: { IP => https_domain }
+        memory: this.kernel.memory
+      })
+    }))
     this.app.get("/pinokio/memory", ex((req, res) => {
       let filepath = req.query.filepath
       let mem = this.getMemory(filepath)
@@ -3893,6 +3904,7 @@ class Server {
         server: this.listening
       });
     })
+    this.kernel.peer.start()
     console.timeEnd("SERVER START")
 
 

package/server/views/proxy.ejs

@@ -161,7 +161,7 @@ body.dark .browser-options-row {
 }
 .container {
   display: grid;
-  grid-template-columns: repeat(3, 1fr);
+  grid-template-columns: repeat(4, 1fr);
 }
 .dark .container-row {
   background: rgba(255, 255, 255, 0.04);
@@ -210,6 +210,14 @@ body.dark .browser-options-row {
   <div class='header-label'><i class='fa-solid fa-wifi'></i> Local Sharing</div>
   <div class='desc'>Serve Pinokio, installed apps, and even external apps to any device on the same network.</div>
   <div class='container'>
+    <div class='container-row'>
+      <div class='header-label-sub'><i class="fa-solid fa-microchip"></i> Peers</div>
+      <% peers.forEach((item) => { %>
+        <a target="_blank" href="http://<%=item%>" class='line align-top'>
+          <h3 class='table-grid'><%=item%></h3>
+        </a>
+      <% }) %>
+    </div>
     <div class='container-row'>
       <div class='header-label-sub'><i class="fa-solid fa-microchip"></i> Apps</div>
       <div class='line align-top'>