pinokiod 3.8.91 → 3.8.93

package/kernel/bin/caddy.js

@@ -15,7 +15,7 @@ class Caddy {
       let response = await axios.get('http://127.0.0.1:2019/config/')
       return true
     } catch (e) {
-      console.log(e)
+      console.log(e.message)
       return false
     }
   }
@@ -34,7 +34,6 @@ class Caddy {
           message: `caddy run --watch`,
           path: this.kernel.homedir,
         }, (e) => {
-          console.log("[CADDY] " + e.cleaned)
           if (!resolved) {
             if (/endpoint started/i.test(e.cleaned)) {
               console.log("######### match")
@@ -46,273 +45,6 @@ class Caddy {
       })
       this.kernel.refresh(true)
     }
-//    const config = {
-//      "apps": {
-//        "http": {
-//          "servers": {
-//            "main": {
-//              "listen": ["127.0.0.1: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"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["l.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "127.0.0.1:1234" }]
-//                    },
-//                    {
-//                      "handler": "headers",
-//                      "response": {
-//                        "set": {
-//                          "Access-Control-Allow-Origin": ["*"],
-//                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-//                          "Access-Control-Allow-Headers": ["*"],
-//                          "Vary": ["Origin"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["o.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "127.0.0.1:11434" }]
-//                    },
-//                    {
-//                      "handler": "headers",
-//                      "response": {
-//                        "set": {
-//                          "Access-Control-Allow-Origin": ["*"],
-//                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-//                          "Access-Control-Allow-Headers": ["*"],
-//                          "Vary": ["Origin"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["a.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "127.0.0.1:7860" }]
-//                    },
-//                    {
-//                      "handler": "headers",
-//                      "response": {
-//                        "set": {
-//                          "Access-Control-Allow-Origin": ["*"],
-//                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-//                          "Access-Control-Allow-Headers": ["*"],
-//                          "Vary": ["Origin"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["b.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "127.0.0.1:7861" }]
-//                    },
-//                    {
-//                      "handler": "headers",
-//                      "response": {
-//                        "set": {
-//                          "Access-Control-Allow-Origin": ["*"],
-//                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-//                          "Access-Control-Allow-Headers": ["*"],
-//                          "Vary": ["Origin"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["c.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "127.0.0.1:7862" }]
-//                    },
-//                    {
-//                      "handler": "headers",
-//                      "response": {
-//                        "set": {
-//                          "Access-Control-Allow-Origin": ["*"],
-//                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-//                          "Access-Control-Allow-Headers": ["*"],
-//                          "Vary": ["Origin"]
-//                        }
-//                      }
-//                    }
-//                  ]
-//                }
-//              ]
-//            }
-//          }
-//        }
-//      }
-//    }
-//
-//    const config2 = {
-//      "apps": {
-//        "http": {
-//          "servers": {
-//            "main": {
-//              "listen": [":443"],
-//              //"listen": [":80"],
-//              "handle_response": [
-//                {
-//                  "handler": "headers",
-//                  "headers": {
-//                    "Access-Control-Allow-Origin": ["*"],
-//                    "Access-Control-Allow-Methods": ["GET", "POST", "OPTIONS", "PUT", "DELETE"],
-//                    "Access-Control-Allow-Headers": ["*"]
-//                  }
-//                }
-//              ],
-//              "routes": [
-//                {
-//                  "match": [{ "method": ["OPTIONS"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "static_response",
-//                      "headers": {
-//                        "Access-Control-Allow-Origin": ["*"],
-//                        "Access-Control-Allow-Methods": ["GET", "POST", "OPTIONS", "PUT", "DELETE"],
-//                        "Access-Control-Allow-Headers": ["*"]
-//                      },
-//                      "status_code": 204
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "localhost:42000" }]
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["l.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "localhost:1234" }]
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["a.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "localhost:7860" }]
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["b.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "localhost:7861" }]
-//                    }
-//                  ]
-//                },
-//                {
-//                  "match": [{ "host": ["c.pinokio.localhost"] }],
-//                  "handle": [
-//                    {
-//                      "handler": "reverse_proxy",
-//                      "upstreams": [{ "dial": "localhost:7862" }]
-//                    }
-//                  ]
-//                }
-//              ]
-//            }
-//          }
-//        },
-////        "tls": {
-////          "automation": {
-////            "policies": [
-////              {
-////                "subjects": [
-////                  "pinokio.localhost",
-////                  "a.pinokio.localhost",
-////                  "b.pinokio.localhost",
-////                  "c.pinokio.localhost"
-////                ],
-////                "issuers": [
-////                  {
-////                    "module": "internal"
-////                  }
-////                ]
-////              }
-////            ]
-////          }
-////        }
-//      }
-//    }
-//
-//
-//
-//
-//    console.log("Make request to caddy", config)
-//    let response = await axios.post('http://127.0.0.1:2019/load', config, {
-//      headers: { 'Content-Type': 'application/json' }
-//    }).catch((e) => {
-//      console.log("EEEEEEEEEEEEE", e)
-//    })
-//    console.log("Caddy Response", { response })
   }
   async install(req, ondata, kernel, id) {
     await this.kernel.bin.exec({
@@ -328,7 +60,6 @@ class Caddy {
         path: this.kernel.homedir,
       }, (e) => {
         resolve()
-        console.log("[CADDY] " + e.cleaned)
         if (!resolved) {
           if (/endpoint started/i.test(e.cleaned)) {
             console.log("######### match")

package/kernel/index.js

@@ -33,6 +33,7 @@ const Proto = require('./prototype')
 const Router = require("./router")
 const Procs = require('./procs')
 const Peer = require('./peer')
+const kill = require('./tree-kill');
 const VARS = {
   pip: {
     install: {
@@ -79,16 +80,16 @@ class Kernel {
     this.jsdom = jsdom
     this.exposed = {}
     this.envs = {}
-    this.info = new Info(this)
-    this.pipe = new Pipe(this)
-    this.proto = new Proto(this)
-    this.processes = new Procs()
-    this.kv = new KV(this)
-    this.cloudflare = new Cloudflare()
+//    this.info = new Info(this)
+//    this.pipe = new Pipe(this)
+//    this.proto = new Proto(this)
+//    this.processes = new Procs()
+//    this.kv = new KV(this)
+//    this.cloudflare = new Cloudflare()
+//    this.peer = new Peer()
     this.shellpath = shellPath.sync()
 
 
-    this.peer = new Peer()
   }
   /*
     kernel.env() => return the system environment
@@ -258,20 +259,23 @@ class Kernel {
   log(data, group, info) {
     this.log_queue.push({ data, group, info })
   }
-  async refresh(broadcast) {
-    console.log("kernel.refresh", { broadcast })
+  async refresh(notify_peers) {
+    console.log("kernel.refresh", { notify_peers })
     await Promise.all([
       // refresh proc info
       this.processes.refresh(),
       // refresh peer info
       this.peer.refresh()
     ])
+    console.log("proc info", this.processes.info)
+    console.log("peer info", this.peer.info)
     // refresh router info
     await this.router.refresh()
+    console.log("router info", this.router.published())
 
-    if (broadcast) {
-      // broadcast to peers
-      await this.peer.broadcast()
+    if (notify_peers) {
+      // broadcast to peers to refresh
+      await this.peer.notify_peers()
     }
   }
   async clearLog(group) {
@@ -477,12 +481,35 @@ class Kernel {
     }
   }
   async init(options) {
+
     let home = this.store.get("home")
 
     // reset shells if they exist
+    console.log("KERNEL INIT")
     if (this.shell) {
+      console.log("> shell reset")
       this.shell.reset()
     }
+    if (this.peer) {
+      console.log("> peer stop")
+      this.peer.stop()
+    }
+
+    // kill all processes just in case
+    await new Promise((resolve, reject) => {
+      kill(process.pid, 'SIGKILL', () => {
+        console.log("child procs killed for", process.pid)
+        resolve()
+      });
+    })
+
+    this.info = new Info(this)
+    this.pipe = new Pipe(this)
+    this.proto = new Proto(this)
+    this.processes = new Procs()
+    this.kv = new KV(this)
+    this.cloudflare = new Cloudflare()
+    this.peer = new Peer()
 
     this.homedir = home
 

package/kernel/loader.js

@@ -6,6 +6,14 @@ const clearModule = require('clear-module');
 
 class Loader {
   async load(_path) {
+
+    let exists = await new Promise(r=>fs.access(_path, fs.constants.F_OK, e => r(!e)))
+    if (!exists) {
+      console.log(`[load] ${_path} does not exist`)
+      return { resolved: null }
+    }
+
+
     let resolved
     let dirname
     let extension = path.extname(_path)

package/kernel/peer.js

@@ -1,80 +1,69 @@
 const dgram = require('dgram');
 const axios = require('axios');
 const os = require('os')
+const Environment = require("./environment")
 class PeerDiscovery {
   constructor(port = 41234, message = 'ping', interval = 1000) {
     this.port = port;
     this.message = Buffer.from(message);
     this.interval = interval;
     this.peers = new Set();
-    this.name = os.userInfo().username
     this.host = this._getLocalIPAddress()
     this.default_port = 42000
 //    this.start();
   }
-  start() {
-    // Listen for incoming pings
-    console.log("kernel.peer start")
-    this.socket = dgram.createSocket('udp4');
-    this.socket.on('message', (msg, rinfo) => {
-      console.log("peer message", { msg, rinfo })
-      const ip = rinfo.address;
-      console.log({rinfo})
-      if (msg.toString() === this.message.toString() && this._isLocalLAN(ip)) {
-        if (!this.peers.has(ip)) {
-          console.log(`Discovered peer: ${ip}`);
-          this.peers.add(ip);
-          this.refresh()
-        }
-      }
-    });
-
-    // Enable broadcast
-    console.log("binding socket")
-    this.socket.bind(this.port, () => {
-      console.log("socket bound")
-      this.socket.setBroadcast(true);
-
-      // Send broadcast pings every interval
-      setInterval(() => {
-        console.log("send message to peers")
-        this.socket.send(this.message, 0, this.message.length, this.port, '255.255.255.255');
+  stop() {
+    if (this.socket) {
+      console.log("peer stop")
+      clearInterval(this.interval)
+      this.socket.close()
+    }
+  }
+  async start(kernel) {
+    let env = await Environment.get(kernel.homedir)
 
-        // if peer exists but info doesn't exist, refresh
-        for(let peer of this.peers) {
-          let refresh_needed = false;
-          let refresh_code;
-          if (this.info[peer]) {
-            if (this.info[peer].router && Object.keys(this.info[peer].router).length > 0) {
-              // router initialized
-              refresh_needed = false;
-            } else {
-              // router not initialized. try again
-              refresh_needed = true;
-              refresh_code = 1 
-            }
+    // by default expose to the local network
+    this.active = false
+    // if PINOKIO_NETWORK_SHARE is 0 or false, turn it off
+    if (env && env.PINOKIO_NETWORK_ACTIVE && (env.PINOKIO_NETWORK_ACTIVE==="1" || env.PINOKIO_NETWORK_ACTIVE.toLowerCase()==="true")) {
+      this.active = true
+    }
 
-            if (this.info[peer].proc && this.info[peer].proc.length > 0) {
-              // router initialized
-              refresh_needed = false;
-            } else {
-              // router not initialized. try again
-              refresh_needed = true;
-              refresh_code = 2
-            }
+    this.name = os.userInfo().username
+    if (env && env.PINOKIO_NETWORK_NAME && env.PINOKIO_NETWORK_NAME.length > 0) {
+      this.name = env.PINOKIO_NETWORK_NAME
+    }
 
-          } else {
-            // try again
-            refresh_needed = true;
-            refresh_code = 3
-          }
-          if (refresh_needed) {
-            console.log("refresh needed", refresh_code)
-            this.refresh([peer])
+    if (this.active) {
+      // Listen for incoming pings
+      console.log("kernel.peer start")
+      this.socket = dgram.createSocket('udp4');
+      this.socket.on('message', (msg, rinfo) => {
+        console.log("peer message", { msg, rinfo })
+        const ip = rinfo.address;
+        console.log({rinfo})
+        if (msg.toString() === this.message.toString() && this._isLocalLAN(ip)) {
+          if (!this.peers.has(ip)) {
+            console.log(`Discovered peer: ${ip}`);
+            this.peers.add(ip);
+            this.refresh()
           }
         }
-      }, this.interval);
-    });
+      });
+
+      // Enable broadcast
+      console.log("binding socket")
+      this.socket.bind(this.port, () => {
+        console.log("socket bound")
+        this.socket.setBroadcast(true);
+
+        // Send broadcast pings every interval
+        this.interval = setInterval(() => {
+          console.log("send message to peers")
+          this.socket.send(this.message, 0, this.message.length, this.port, '255.255.255.255');
+        }, this.interval);
+      });
+    }
   }
   async _refresh(host) {
     try {
@@ -98,36 +87,40 @@ class PeerDiscovery {
     }
   }
   // notify peers to refresh my info
-  async broadcast() {
-    let res = await Promise.all(Array.from(this.peers).map((host) => {
-      return this._broadcast(host)
-    }))
-    return res
+  async notify_peers() {
+    if (this.active) {
+      let res = await Promise.all(Array.from(this.peers).map((host) => {
+        return this._broadcast(host)
+      }))
+      return res
+    }
   }
   // refresh peer info
   async refresh(peers) {
-    let refresh_peers
-    if (peers) {
-      refresh_peers = peers
-    } else {
-      this.info = {}
-      refresh_peers = Array.from(this.peers)
-    }
-    let peer_info = await Promise.all(refresh_peers.map((host) => {
-      return this._refresh(host)
-    }))
-    console.log({ peer_info })
-    for(let i=0; i<peer_info.length; i++) {
-      let peer = peer_info[i]
-      if (peer) {
-        this.info[peer.host] = {
-          host: peer.host,
-          ...peer
+    if (this.active) {
+      let refresh_peers
+      if (peers) {
+        refresh_peers = peers
+      } else {
+        this.info = {}
+        refresh_peers = Array.from(this.peers)
+      }
+      let peer_info = await Promise.all(refresh_peers.map((host) => {
+        return this._refresh(host)
+      }))
+      console.log({ peer_info })
+      for(let i=0; i<peer_info.length; i++) {
+        let peer = peer_info[i]
+        if (peer) {
+          this.info[peer.host] = {
+            host: peer.host,
+            ...peer
+          }
         }
       }
+      console.log("REFRESH", this.info)
+      return this.info
     }
-    console.log("REFRESH", this.info)
-    return this.info
   }
   _isLocalLAN(ip) {
     return ip.startsWith('192.168.');

package/kernel/router/index.js

@@ -198,7 +198,7 @@ class Router {
       let response = await axios.post('http://127.0.0.1:2019/load', this.config, {
         headers: { 'Content-Type': 'application/json' }
       }).catch((e) => {
-        console.log("EEEEEEEEEEEEE", e)
+        console.log("EEEEEEEEEEEEE", e.message)
       })
       console.log("Caddy Response", { response })
     }

package/kernel/shell.js

@@ -2,7 +2,7 @@ const { Terminal } = require('xterm-headless');
 const { SerializeAddon } = require("xterm-addon-serialize");
 const sanitize = require("sanitize-filename");
 const YAML = require('yaml')
-const kill = require('tree-kill');
+const kill = require('./tree-kill');
 const fastq = require('fastq')
 const { v4: uuidv4 } = require('uuid');
 const os = require('os');
@@ -251,6 +251,7 @@ class Shell {
     this.ondata({ raw: `\r\n████\r\n██ Starting Shell ${this.id}\r\n` })
 
 
+    this.params = params
 
     // 3. path => path can be http, relative, absolute
     this.path = params.path
@@ -258,6 +259,7 @@ class Shell {
     // automatically add self to the shells registry
     this.kernel.shell.add(this)
 
+
     if (params.sudo) {
       let options = {
         name: "Pinokio",
@@ -977,23 +979,30 @@ class Shell {
     this.queue.killAndDrain()
     if (this.ptyProcess) {
       if (cb) {
-        console.log("tree kill", this.ptyProcess.pid)
         kill(this.ptyProcess.pid, 'SIGKILL', () => {
+          console.log("child procs killed for", this.ptyProcess.pid)
           this.ptyProcess.kill()
           this.ptyProcess = undefined
+          // automatically remove the shell from this.kernel.shells
+          this.kernel.shell.rm(this.id)
+          this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
           cb()
         });
       } else {
-        console.log("tree kill", this.ptyProcess.pid)
         kill(this.ptyProcess.pid, 'SIGKILL');
+        console.log("child procs killed for", this.ptyProcess.pid)
         this.ptyProcess.kill()
         this.ptyProcess = undefined
+        // automatically remove the shell from this.kernel.shells
+        this.kernel.shell.rm(this.id)
+        this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
       }
+    } else {
+  //    // automatically remove the shell from this.kernel.shells
+      this.kernel.shell.rm(this.id)
+      this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
     }
 
-    // automatically remove the shell from this.kernel.shells
-    this.kernel.shell.rm(this.id)
-    this.ondata({ raw: `\r\n\r\n██ Terminated Shell ${this.id}\r\n████\r\n` })
 
   }
   log() {

package/kernel/shells.js

@@ -362,7 +362,7 @@ class Shells {
     let info = this.shells.map((s) => {
       return { id: s.id, group: s.group, cmd: s.cmd }
     })
-    if (this.shells) {
+    if (this.shells && this.shells.length > 0) {
       let shells = []
       for(let i=0; i<this.shells.length; i++) {
         shells.push(this.shells[i])
@@ -381,6 +381,9 @@ class Shells {
           shell.kill("", true)
         }
       }
+    } else {
+      console.log("no shells running")
+      cb()
     }
   }
   kill(request, message) {
@@ -448,7 +451,6 @@ 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/tree-kill.js

@@ -0,0 +1,165 @@
+'use strict';
+
+var childProcess = require('child_process');
+var spawn = childProcess.spawn;
+var exec = childProcess.exec;
+var execSync = childProcess.execSync;
+
+module.exports = function (pid, signal, callback) {
+    if (typeof signal === 'function' && callback === undefined) {
+        callback = signal;
+        signal = undefined;
+    }
+
+    pid = parseInt(pid);
+    if (Number.isNaN(pid)) {
+        if (callback) {
+            return callback(new Error("pid must be a number"));
+        } else {
+            throw new Error("pid must be a number");
+        }
+    }
+
+    var tree = {};
+    var pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+
+    switch (process.platform) {
+    case 'win32':
+        exec('taskkill /pid ' + pid + ' /T /F', callback);
+        break;
+    case 'darwin':
+        buildProcessTreeMacOS(pid, tree, pidsToProcess, function () {
+          killAll(tree, signal, callback);
+        });
+        break;
+    // case 'sunos':
+    //     buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+    //         killAll(tree, signal, callback);
+    //     });
+    //     break;
+    default: // Linux
+        buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+          return spawn('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid]);
+        }, function () {
+            killAll(tree, signal, callback);
+        });
+        break;
+    }
+};
+
+function killAll (tree, signal, callback) {
+    var killed = {};
+    try {
+        Object.keys(tree).forEach(function (pid) {
+            tree[pid].forEach(function (pidpid) {
+                if (!killed[pidpid]) {
+                    killPid(pidpid, signal);
+                    killed[pidpid] = 1;
+                }
+            });
+            // exception: if the pid is the current process,
+            // kill all subprocesses, but do NOT kill the current process
+            if (String(pid) === String(process.pid)) {
+              return
+            }
+            if (!killed[pid]) {
+                killPid(pid, signal);
+                killed[pid] = 1;
+            }
+        });
+    } catch (err) {
+        if (callback) {
+            return callback(err);
+        } else {
+            throw err;
+        }
+    }
+    if (callback) {
+        return callback();
+    }
+}
+
+function killPid(pid, signal) {
+    try {
+        process.kill(parseInt(pid, 10), signal);
+    }
+    catch (err) {
+        if (err.code !== 'ESRCH') throw err;
+    }
+}
+
+function buildProcessTree (parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+    var ps = spawnChildProcessesList(parentPid);
+    var allData = '';
+    ps.stdout.on('data', function (data) {
+        var data = data.toString('ascii');
+        allData += data;
+    });
+
+    var onClose = function (code) {
+        delete pidsToProcess[parentPid];
+
+        if (code != 0) {
+            // no more parent processes
+            if (Object.keys(pidsToProcess).length == 0) {
+                cb();
+            }
+            return;
+        }
+
+        allData.match(/\d+/g).forEach(function (pid) {
+          pid = parseInt(pid, 10);
+          tree[parentPid].push(pid);
+          tree[pid] = [];
+          pidsToProcess[pid] = 1;
+          buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+        });
+    };
+
+    ps.on('close', onClose);
+}
+
+function buildProcessTreeMacOS(parentPid, tree, pidsToProcess, cb) {
+    try {
+        let stdout = '';
+        try {
+            stdout = execSync('pgrep -P ' + parentPid, {
+                encoding: 'utf8',
+                timeout: 2000,
+                maxBuffer: 1024 * 1024
+            });
+        } catch (execError) {
+            if (execError.status !== 1) {
+                throw execError;
+            }
+        }
+
+        delete pidsToProcess[parentPid];
+
+        const childPids = stdout.trim().split('\n').filter(Boolean);
+        
+        if (childPids.length === 0) {
+            if (Object.keys(pidsToProcess).length === 0) {
+                cb();
+            }
+            return;
+        }
+
+        childPids.forEach(function(pidStr) {
+            const pid = parseInt(pidStr, 10);
+            if (!isNaN(pid)) {
+                tree[parentPid].push(pid);
+                tree[pid] = [];
+                pidsToProcess[pid] = 1;
+                buildProcessTreeMacOS(pid, tree, pidsToProcess, cb);
+            }
+        });
+    } catch (err) {
+        delete pidsToProcess[parentPid];
+        if (Object.keys(pidsToProcess).length === 0) {
+            cb();
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.8.91",
+  "version": "3.8.93",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -59,7 +59,6 @@
     "sudo-prompt-programfiles-x86": "^9.2.10",
     "symlink-dir": "^5.2.1",
     "systeminformation": "^5.18.4",
-    "tree-kill": "^1.2.2",
     "uuid": "^9.0.0",
     "wait-on": "^7.2.0",
     "which": "^5.0.0",

package/server/index.js

@@ -1,4 +1,5 @@
 const express = require('express');
+const kill = require('../kernel/tree-kill');
 const portfinder = require('portfinder-cp');
 const proxy = require('express-http-proxy-cp');
 const sudo = require("sudo-prompt-programfiles-x86");
@@ -2256,6 +2257,8 @@ class Server {
       }
     }
     // initialize kernel
+
+
     await this.kernel.init({ port: this.port})
 
 
@@ -2623,6 +2626,7 @@ class Server {
     }))
     this.app.get("/network", ex(async (req, res) => {
       let list = []
+
 //      let peers_info = await this.kernel.peer.refresh()
       let peers_info = {}
       if (this.kernel.peer.info) {
@@ -2677,31 +2681,6 @@ class Server {
         }
       }
       console.log({ peers_info })
-        
-//      if (this.kernel.processes.info) {
-//        console.log("proc info", this.kernel.processes.info)
-//        list = this.kernel.processes.info.map((item) => {
-//          console.log("item", item)
-//          console.log("item.ip", item.ip)
-//          let internal_port = item.ip.split(":")[1]
-//          let external_port = this.kernel.router.port_mapping[internal_port]
-//          if (external_port) {
-//            let external_ip = `${this.kernel.peer.host}:${external_port}`
-//            console.log({ internal_port, external_port, external_ip })
-//            return {
-//              //proxy: this.kernel.caddy.mapping[item.ip] || [],
-//              router: info[this.kernel.peer.host][external_ip] || [],
-//              external_ip,
-//              ...item
-//            }
-//          } else {
-//            return {
-//              router: [],
-//              ...item
-//            }
-//          }
-//        })
-//      }
 
       let peers = []
       for(let host in peers_info) {
@@ -2713,20 +2692,6 @@ class Server {
           router: `https://pinokio.${peer_info.name}.localhost/proxy`
         })
       }
-
-//      let peers = this.kernel.peer.get()
-//      peers = peers.map((x) => {
-//        let account = this.kernel.peer.account(x)
-//        let domain = `https://pinokio.${account}.localhost`
-//        let proxy_page = `https://pinokio.${account}.localhost/proxy`
-//        return {
-//          ip: x,
-//          account,
-//          domain,
-//          proxy_page
-//        }
-//      })
-
       let live_proxies = this.kernel.api.proxies["/proxy"]
       if (!live_proxies) live_proxies = []
       let proxies = []
@@ -2798,6 +2763,8 @@ class Server {
         ip: this.kernel.peer.current_ip,
         peers,
         list,
+        name: this.kernel.peer.name,
+        active: this.kernel.peer.active,
         port_mapping: this.kernel.router.port_mapping,
 //        port_mapping: this.kernel.caddy.port_mapping,
 //        ip_mapping: this.kernel.caddy.ip_mapping,
@@ -3336,7 +3303,7 @@ class Server {
     }))
     this.app.get("/pinokio/peer", ex(async (req, res) => {
       console.log("/pinokio/peer", { proc: this.kernel.processes.info })
-      await this.kernel.refresh()
+//      await this.kernel.refresh()
       res.json({
         home: this.kernel.homedir,
         arch: this.kernel.arch,
@@ -3904,6 +3871,36 @@ class Server {
       console.log({ requirements_pending })
       res.json({ requirements_pending })
     }))
+    this.app.get("/check_peer", ex((req, res) => {
+      if (this.kernel.peer.active) {
+        // if network is active, return success only if the router is up for all of its peers (including itself)
+        console.log({ peer_info: this.kernel.peer.info })
+        let ready = true
+        if (this.kernel.peer.info) {
+          for(let host in this.kernel.peer.info) {
+            let info = this.kernel.peer.info[host]
+            if (info.router && Object.keys(info.router).length > 0) {
+              ready = true 
+            } else {
+              ready = false
+              break;
+            }
+          }
+        } else {
+          ready = false;
+        }
+        console.log({ info: this.kernel.peer.info, ready })
+        if (ready) {
+          res.json({ success: true })
+        } else {
+          res.json({ success: false })
+        }
+      } else {
+        // if network is not active, return success immediately (just checking if the server is up)
+        console.log("this.kernel.router.published()")
+        res.json({ success: true })
+      }
+    }))
     this.app.get("/check", ex((req, res) => {
       res.json({ success: true })
     }))
@@ -3911,6 +3908,16 @@ class Server {
       console.log("post /restart")
       this.start({ debug: this.debug, browser: this.browser })
     }))
+    this.app.post("/network", ex(async (req, res) => {
+      if (this.kernel.homedir) {
+        let fullpath = path.resolve(this.kernel.homedir, "ENVIRONMENT")
+        await Util.update_env(fullpath, req.body)
+        res.json({ success: true })
+      } else {
+        res.json({ error: "homedir doesn't exist" })
+      }
+    }))
+
     this.app.post("/config", ex(async (req, res) => {
       try {
         await this.setConfig(req.body)
@@ -3932,24 +3939,33 @@ class Server {
       })
     });
     process.on('SIGINT', () => {
-      console.log("SIGINT Event")
-      if (this.kernel && this.kernel.shell) {
-        this.kernel.shell.reset(() => {
-          process.exit()
-        })
-      } else {
+      //if (this.kernel && this.kernel.shell) {
+      //  console.log("shell reset")
+      //  this.kernel.shell.reset(() => {
+      //    process.exit()
+      //  })
+      //} else {
+      //  process.exit()
+      //}
+      kill(process.pid, 'SIGKILL', () => {
+        console.log("child procs killed for", process.pid)
         process.exit()
-      }
+      });
     })
+
     process.on('SIGTERM', () => {
-      console.log("SIGTERM Event")
-      if (this.kernel && this.kernel.shell) {
-        this.kernel.shell.reset(() => {
-          process.exit()
-        })
-      } else {
+//      if (this.kernel && this.kernel.shell) {
+//        console.log("shell reset")
+//        this.kernel.shell.reset(() => {
+//          process.exit()
+//        })
+//      } else {
+//        process.exit()
+//      }
+      kill(process.pid, 'SIGKILL', () => {
+        console.log("child procs killed for", process.pid)
         process.exit()
-      }
+      });
     })
 //    process.on('exit', () => {
 //      console.log("exit Event")
@@ -3973,7 +3989,7 @@ class Server {
         server: this.listening
       });
     })
-    this.kernel.peer.start()
+    this.kernel.peer.start(this.kernel)
 
 
   }

package/server/views/network.ejs

@@ -156,7 +156,9 @@ body.dark .browser-options-row {
   padding: 0;
   font-size: 50px;
   letter-spacing: -1px;
+  /*
   text-align: center;
+  */
   text-transform: capitalize;
 }
 .header-label-sub h1 {
@@ -181,7 +183,6 @@ body.dark .browser-options-row {
   box-sizing: border-box;
 }
 .container {
-  margin-top: 20px;
   display: grid;
   grid-template-columns: repeat(<%=list.length%>, 1fr);
 }
@@ -194,8 +195,10 @@ body.dark .browser-options-row {
   box-sizing: border-box;
 }
 .desc {
+/*
   text-align:center;
-  padding: 10px;
+  */
+  padding: 10px 0;
 }
 .container-row table {
   width: 100%;
@@ -222,6 +225,105 @@ td:first-child, th:first-child {
   font-size: 14px;
   padding: 2px;
 }
+
+.config {
+  background: rgba(0,0,0,0.9);
+  color: white;
+  padding: 30px;
+  text-align: left;
+}
+.config-header {
+}
+.config-body {
+  display: flex;
+  align-items: flex-end;
+}
+.config .btn {
+  font-size: 16px;
+  font-weight: bold;
+  width: 100px;
+  background: royalblue;
+  flex-shrink: 0;
+}
+.config-row {
+  padding: 10px 20px 0 0;
+}
+.config-row .label {
+  padding-bottom: 5px;
+  font-weight: bold;
+}
+.config-row input[type=text] {
+  padding: 7px;
+}
+
+.switcher {
+  position: relative;
+  display: inline-block;
+  width: 60px;
+  height: 34px;
+}
+
+.switcher input { 
+  opacity: 0;
+  width: 0;
+  height: 0;
+}
+
+.slider {
+  position: absolute;
+  cursor: pointer;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: #ccc;
+  -webkit-transition: .4s;
+  transition: .4s;
+}
+
+.slider:before {
+  position: absolute;
+  content: "";
+  height: 26px;
+  width: 26px;
+  left: 4px;
+  bottom: 4px;
+  background-color: white;
+  -webkit-transition: .4s;
+  transition: .4s;
+}
+
+input:checked + .slider {
+/*
+  background-color: #2196F3;
+  */
+  background-color: royalblue;
+}
+
+input:focus + .slider {
+  box-shadow: 0 0 1px #2196F3;
+}
+
+input:checked + .slider:before {
+  -webkit-transform: translateX(26px);
+  -ms-transform: translateX(26px);
+  transform: translateX(26px);
+}
+
+/* Rounded sliders */
+.slider.round {
+  border-radius: 34px;
+}
+
+.slider.round:before {
+  border-radius: 50%;
+}
+.loading {
+  text-align: center;
+  padding: 50px;
+}
+
+
 @media only screen and (max-width: 480px) {
   .btn2 {
     padding: 5px;
@@ -254,8 +356,30 @@ td:first-child, th:first-child {
 </h1>
 </header>
 <main>
-  <div class='header-label'><i class='fa-solid fa-wifi'></i> Network</div>
-  <div class='desc'>Serve Pinokio, installed apps, and even external apps to any device on the same network.</div>
+  <div class='config'>
+    <div class='config-header'>
+      <div class='header-label'><i class='fa-solid fa-wifi'></i> Network</div>
+      <div class='desc'>Serve Pinokio, installed apps, and even external apps to any device on the same network.</div>
+    </div>
+    <div class='config-body'>
+      <div class='config-row'>
+        <div class='label'>Network Name</div>
+        <input id='name' type='text' value="<%=name%>">
+      </div>
+      <div class='config-row'>
+        <div class='label'>Network Share</div>
+        <label class="switcher">
+          <input id='active' type="checkbox" <%=active ? 'checked' : ''%>>
+          <span class="slider"></span>
+        </label>
+      </div>
+      <div class='flexible'></div>
+      <button class='btn save'>Save</button>
+    </div>
+  </div>
+  <div class='loading hidden'>
+    <i class="fa-solid fa-circle-notch fa-spin"></i> Stand by. Do not close this window..
+  </div>
   <!--
   <div class='header-container'>
     <div class='header-label-sub'><i class="fa-solid fa-podcast"></i> Local Network</div>
@@ -393,8 +517,57 @@ td:first-child, th:first-child {
   </div>
 </main>
 <script>
-document.querySelector(".container").addEventListener("click", async (e) => {
+document.querySelector("main").addEventListener("click", async (e) => {
   let target
+
+  if (e.target.classList.contains("save")) {
+    target = e.target
+  } else {
+    target = e.target.closest(".save")
+  }
+
+  if (target) {
+    let body = {
+      PINOKIO_NETWORK_NAME: document.querySelector("#name").value,
+      PINOKIO_NETWORK_ACTIVE: (document.querySelector("#active").checked ? "1": "0")
+    }
+    console.log(body)
+    debugger
+    let r = await fetch("/network", {
+      method: "post",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then((res) => {
+      return res.json()
+    })
+    if (r.success) {
+      //alert("Successfully updated the pinokio home to " + val)
+      document.querySelector(".loading").classList.remove("hidden")
+      document.querySelector(".save").classList.add("hidden")
+      fetch("/restart", {
+        method: "post"
+      }, () => {
+      })
+      setInterval(async () => {
+        try {
+          let res = await fetch("/check_peer").then((res) => {
+            return res.json()
+          })
+          if (res.success) {
+            document.querySelector(".loading").classList.add("hidden")
+            location.href = location.href
+          }
+        } catch (e) {
+          console.log(e)
+        }
+      }, 1000)
+    } else if (r.error) {
+      alert(r.error)
+      location.href = location.href
+    }
+    return
+  }
+
   if (e.target.classList.contains("stop")) {
     target = e.target
   } else {
@@ -467,6 +640,7 @@ document.querySelector(".container").addEventListener("click", async (e) => {
     })
   }
 
+
 })
 if (document.querySelector("#back")) {
   document.querySelector("#back").addEventListener("click", (e) => {