pinokiod 5.1.10 → 5.1.11

package/kernel/index.js

@@ -89,6 +89,11 @@ class Kernel {
     this.pinokio_configs = {}
     this.shellpath = shellPath.sync()
     this.favicon = new Favicon()
+    this.vram = 0
+    this.ram = 0
+    this.sysReady = new Promise((resolve) => {
+      this._resolveSysReady = resolve
+    })
 
 
   }
@@ -999,9 +1004,16 @@ class Kernel {
 
       }
 
+      // Load git checkpoints as soon as homedir is ready so features depending on it
+      // (like the Backups page) can see prior state immediately.
+      console.time("git.loadCheckpoints")
+      await this.git.loadCheckpoints()
+      console.timeEnd("git.loadCheckpoints")
+
 //      let contents = await fs.promises.readdir(this.homedir)
       //await this.bin.init()
       let ts = Date.now()
+      // Initialize core tools
       this.bin.init().then(() => {
         if (this.homedir) {
           this.git.init().then(() => {
@@ -1053,6 +1065,10 @@ class Kernel {
               this.sysinfo = info
 
               await this.getInfo(true)
+              if (this._resolveSysReady) {
+                this._resolveSysReady()
+                this._resolveSysReady = null
+              }
 
               await fs.promises.mkdir(this.path("logs"), { recursive: true }).catch((e) => { })
               await fs.promises.writeFile(this.path("logs/system.json"), JSON.stringify(this.i, null, 2))
@@ -1064,39 +1080,49 @@ class Kernel {
               // get env
               if (!this.launch_complete) {
                 let interval = setInterval(async () => {
-                  if (this.i) {
-                    for(let api of this.i.api) {
-                      let env_path = path.resolve(this.api.userdir, api.path)
-                      let e = await Environment.get(env_path, this)
-                      if (e.PINOKIO_SCRIPT_AUTOLAUNCH && e.PINOKIO_SCRIPT_AUTOLAUNCH.trim().length > 0) {
-                        let autolaunch_path = path.resolve(env_path, e.PINOKIO_SCRIPT_AUTOLAUNCH)
-                        let exists = await this.exists(autolaunch_path)
-                        if (exists) {
-                          this.api.process({
-                            uri: autolaunch_path,
-                            input: {}
+                  try {
+                    if (this.i) {
+                      for (let api of this.i.api) {
+                        let env_path = path.resolve(this.api.userdir, api.path)
+                        let e = await Environment.get(env_path, this)
+                        if (e.PINOKIO_SCRIPT_AUTOLAUNCH && e.PINOKIO_SCRIPT_AUTOLAUNCH.trim().length > 0) {
+                          let autolaunch_path = path.resolve(env_path, e.PINOKIO_SCRIPT_AUTOLAUNCH)
+                          let exists = await this.exists(autolaunch_path)
+                          if (exists) {
+                            this.api.process({
+                              uri: autolaunch_path,
+                              input: {}
             //                client: req.client,
             //                caller: req.parent.path,
-                          }, (r) => {
-                            console.log({ autolaunch_path, r })
+                            }, (r) => {
+                              console.log({ autolaunch_path, r })
 //                              resolve(r.input)
-                          })
-                        } else {
-                          console.log("SCRIPT DOES NOT EXIST. Ignoring.", autolaunch_path)
+                            }).catch((err) => {
+                              console.warn('[Kernel.init] autolaunch process failed:', err && err.message ? err.message : err)
+                            })
+                          } else {
+                            console.log("SCRIPT DOES NOT EXIST. Ignoring.", autolaunch_path)
+                          }
                         }
                       }
+                      clearInterval(interval)
+                      setTimeout(() => {
+                        this.launch_complete = true
+                        console.log("SETTING launch complete", this.launch_complete)
+                      }, 2000)
                     }
-                    clearInterval(interval)
-                    setTimeout(() => {
-                      this.launch_complete = true
-                      console.log("SETTING launch complete", this.launch_complete)
-                    }, 2000)
+                  } catch (err) {
+                    console.warn('[Kernel.init] autolaunch loop failed:', err && err.message ? err.message : err)
                   }
                 }, 1000)
               }
             }
+          }).catch((err) => {
+            console.warn("Shell init error:", err && err.message ? err.message : err)
           })
         }
+      }).catch((err) => {
+        console.warn("Bin init error:", err && err.message ? err.message : err)
       })
       let ts2 = Date.now()
       await this.api.init()
@@ -1109,6 +1135,8 @@ class Kernel {
           system,
           platform: this.platform,
           arch: this.arch,
+          vram: this.vram,
+          ram: this.ram,
           proxy: (port) => {
             return this.api.get_proxy_url("/proxy", port)
           },
@@ -1118,19 +1146,24 @@ class Kernel {
 //        }, 3000)
 
         // refresh every 5 second
-        if (this.refresh_interval) {
-          clearInterval(this.refresh_interval)
-        }
-        //let network_active = await this.network_active()
-        //if (network_active) {
-          this.refresh_interval = setInterval(() => {
+        const scheduleRefresh = () => {
+          if (this.refresh_interval) {
+            clearTimeout(this.refresh_interval)
+          }
+          this.refresh_interval = setTimeout(async () => {
             if (this.server_running) {
-              this.refresh(true)    
+              try {
+                await this.refresh(true)
+              } catch (err) {
+                console.warn('[Kernel.refresh] background refresh failed:', err && err.message ? err.message : err)
+              }
             } else {
               console.log("server not running yet. retry network refresh in 5 secs")
             }
+            scheduleRefresh()
           }, 5000)
-        //}
+        }
+        scheduleRefresh()
 
       }
 
@@ -1148,13 +1181,15 @@ class Kernel {
   async update_sysinfo() {
     try {
       if (this.sys) {
-        await this.sys.refresh()
+//        await this.sys.refresh()
         let info = this.sys.info
         this.template.update(info)
         this.sysinfo = info
         this.gpu = info.gpu
         this.gpu_model = info.gpu_model
         this.gpus = info.gpus
+        this.vram = typeof info.vram === "number" ? info.vram : 0
+        this.ram = typeof info.ram === "number" ? info.ram : 0
       }
     } catch (e) {
       console.log("sysinfo error", e)

package/kernel/peer.js

@@ -74,7 +74,7 @@ class PeerDiscovery {
       return fallback
     }
 
-    const peer_active = resolveFlag('PINOKIO_NETWORK_ACTIVE', true)
+    const peer_active = resolveFlag('PINOKIO_NETWORK_ACTIVE', false)
     const https_active = resolveFlag('PINOKIO_HTTPS_ACTIVE', false)
 //    console.log("kernel.refresh", { active, notify_peers })
 
@@ -101,7 +101,6 @@ class PeerDiscovery {
   async start(kernel) {
     await this.check(kernel)
 
-    //if (this.active) {
     if (this.peer_active) {
       // Listen for incoming pings
       this.socket = dgram.createSocket('udp4');

package/kernel/plugin.js

@@ -64,14 +64,6 @@ class Plugin {
         return
       }
     } else {
-      if (this.kernel.bin.installed && this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git")) {
-        await this.kernel.exec({
-          message: "git pull",
-          path: this.kernel.path("plugin/code")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-      }
       await this.setConfig()
     }
   }

package/kernel/procs.js

@@ -163,12 +163,29 @@ class Procs {
   }
   getPortPidList(cb) {
     const cmd = isWin ? 'netstat -ano -p tcp' : 'lsof -nP -iTCP -sTCP:LISTEN';
-    let d = Date.now()
-    exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, async (err, stdout) => {
-      this.get_pids(stdout).then((pids) => {
-        cb(pids)
-      })
-    });
+    try {
+      exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, async (err, stdout) => {
+        if (err) {
+          console.warn('[Procs] getPortPidList failed:', err && err.message ? err.message : err)
+          cb([])
+          return
+        }
+        try {
+          this.get_pids(stdout || '').then((pids) => {
+            cb(pids)
+          }).catch((e) => {
+            console.warn('[Procs] get_pids failed:', e && e.message ? e.message : e)
+            cb([])
+          })
+        } catch (e) {
+          console.warn('[Procs] get_pids threw:', e && e.message ? e.message : e)
+          cb([])
+        }
+      });
+    } catch (e) {
+      console.warn('[Procs] spawn getPortPidList failed:', e && e.message ? e.message : e)
+      cb([])
+    }
   }
   get_name(stdout) {
     const lines = stdout.trim().split('\n');
@@ -206,42 +223,81 @@ class Procs {
       return
     }
     const cmd = isWin ? 'tasklist /fo csv /nh' : 'ps -Ao pid,comm';
-    exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, async (err, stdout) => {
-      let map = this.get_name(stdout)
-      if (!this.port_map) {
-        this.port_map = {}
-      }
-      for(let key in map) {
-        this.port_map[key] = map[key]
-      }
-      cb(this.port_map)
-    });
+    try {
+      exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, async (err, stdout) => {
+        if (err) {
+          console.warn('[Procs] getPidToNameMap failed:', err && err.message ? err.message : err)
+          cb(this.port_map || {})
+          return
+        }
+        let map
+        try {
+          map = this.get_name(stdout || '')
+        } catch (e) {
+          console.warn('[Procs] get_name threw:', e && e.message ? e.message : e)
+          cb(this.port_map || {})
+          return
+        }
+        if (!this.port_map) {
+          this.port_map = {}
+        }
+        for(let key in map) {
+          this.port_map[key] = map[key]
+        }
+        cb(this.port_map)
+      });
+    } catch (e) {
+      console.warn('[Procs] spawn getPidToNameMap failed:', e && e.message ? e.message : e)
+      cb(this.port_map || {})
+    }
   }
   async refresh() {
+    if (this.kernel && typeof this.kernel.binCheckDepth === 'number' && this.kernel.binCheckDepth > 0) {
+      return
+    }
     let map = {}
     this.refreshing = true
-    let ts = Date.now()
-    let list = await new Promise((resolve, reject) => {
-      this.getPortPidList((portPidList) => {
-        this.getPidToNameMap(portPidList, (pidToName) => {
-          let list = portPidList.map(({ port, pid, ip }) => {
-            const fullname = pidToName[pid] || 'Unknown';
-            const name = fullname.split(path.sep).pop()
-            if (["caddy", "caddy.exe"].includes(name)) {
-              this.caddy_pid = pid
-              return null
-            } else {
-              map["" + pid] =  fullname
-              return { port, pid , name, fullname, ip }
+    try {
+      let list = await new Promise((resolve, reject) => {
+        try {
+          this.getPortPidList((portPidList) => {
+            if (!Array.isArray(portPidList) || portPidList.length === 0) {
+              resolve([])
+              return
             }
-          }).filter((x) => { return x })
-          resolve(list)
-        })
+            this.getPidToNameMap(portPidList, (pidToName) => {
+              try {
+                let list = portPidList.map(({ port, pid, ip }) => {
+                  const fullname = pidToName[pid] || 'Unknown';
+                  const name = fullname.split(path.sep).pop()
+                  if (["caddy", "caddy.exe"].includes(name)) {
+                    this.caddy_pid = pid
+                    return null
+                  } else {
+                    map["" + pid] =  fullname
+                    return { port, pid , name, fullname, ip }
+                  }
+                }).filter((x) => { return x })
+                resolve(list)
+              } catch (e) {
+                console.warn('[Procs] refresh mapping failed:', e && e.message ? e.message : e)
+                resolve([])
+              }
+            })
+          })
+        } catch (e) {
+          reject(e)
+        }
       })
-    })
-    this.info = list
-    this.map = map
-    this.refreshing = false
+      this.info = list
+      this.map = map
+    } catch (e) {
+      console.warn('[Procs] refresh failed:', e && e.message ? e.message : e)
+      this.info = []
+      this.map = {}
+    } finally {
+      this.refreshing = false
+    }
   }
 }
 module.exports = Procs

package/kernel/prototype.js

@@ -14,14 +14,7 @@ class Proto {
 
       // if ~/pinokio/prototype doesn't exist, clone
       let exists = await this.kernel.exists("prototype/system")
-      if (exists) {
-        await this.kernel.exec({
-          message: "git pull",
-          path: this.kernel.path("prototype/system")
-        }, (e) => {
-          process.stdout.write(e.raw)
-        })
-      } else {
+      if (!exists) {
         console.log("prototype doesn't exist. cloning...")
         await fs.promises.mkdir(this.kernel.path("prototype"), { recursive: true }).catch((e) => { })
         await this.kernel.exec({
@@ -31,20 +24,26 @@ class Proto {
           process.stdout.write(e.raw)
         })
       }
-      await this.kernel.download({
-        uri: "https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md",
-        path: this.kernel.path("prototype"),
-        filename: "PINOKIO.md"
-      }, (e) => {
-        process.stdout.write(e.raw)
-      })
-      await this.kernel.download({
-        uri: "https://raw.githubusercontent.com/pinokiocomputer/pterm/refs/heads/main/README.md",
-        path: this.kernel.path("prototype"),
-        filename: "PTERM.md"
-      }, (e) => {
-        process.stdout.write(e.raw)
-      })
+      let pinokio_exists = await this.kernel.exists("prototype/PINOKIO.md")
+      if (!pinokio_exists) {
+        await this.kernel.download({
+          uri: "https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md",
+          path: this.kernel.path("prototype"),
+          filename: "PINOKIO.md"
+        }, (e) => {
+          process.stdout.write(e.raw)
+        })
+      }
+      let pterm_exists = await this.kernel.exists("prototype/PTERM.md")
+      if (!pterm_exists) {
+        await this.kernel.download({
+          uri: "https://raw.githubusercontent.com/pinokiocomputer/pterm/refs/heads/main/README.md",
+          path: this.kernel.path("prototype"),
+          filename: "PTERM.md"
+        }, (e) => {
+          process.stdout.write(e.raw)
+        })
+      }
     }
   }
   async ai() {
@@ -74,6 +73,7 @@ class Proto {
     await fs.promises.rm(this.kernel.path("prototype"), { recursive: true })
   }
   async create(req, ondata) {
+    let uploadTmpDir = null;
     try {
       if (req.client) {
         this.kernel.client = req.client
@@ -88,6 +88,23 @@ class Proto {
       payload.cwd = path.resolve(cwd, name)
       payload.input = req.params
 
+      const uploadToken = req.params && req.params.uploadToken ? String(req.params.uploadToken).trim() : ''
+      if (uploadToken) {
+        uploadTmpDir = this.kernel.path("tmp", "create", uploadToken)
+        const exists = await this.kernel.exists(uploadTmpDir)
+        if (!exists) {
+          throw new Error("Upload token not found or expired")
+        }
+        await fs.promises.mkdir(payload.cwd, { recursive: true })
+        const entries = await fs.promises.readdir(uploadTmpDir, { withFileTypes: true })
+        for (const entry of entries) {
+          if (!entry.isFile()) continue
+          const src = path.resolve(uploadTmpDir, entry.name)
+          const dest = path.resolve(payload.cwd, entry.name)
+          await fs.promises.copyFile(src, dest)
+        }
+      }
+
 
       // 1. move mkdir into each launcher
       // 2. run logic
@@ -138,6 +155,12 @@ class Proto {
     } catch (e) {
       console.log("ERROR", e)
       return { error: e.stack }
+    } finally {
+      if (uploadTmpDir) {
+        try {
+          await fs.promises.rm(uploadTmpDir, { recursive: true, force: true })
+        } catch (_) {}
+      }
     }
   }
   async readme(proto) {

package/kernel/shells.js

@@ -158,9 +158,29 @@ class Shells {
     }
 
     let exec_path = (params.path ? params.path : ".")                         // use the current path if not specified
-    let cwd = (options && options.cwd ? options.cwd : this.kernel.homedir)   // if cwd exists, use it. Otherwise the cwd is pinokio home folder (~/pinokio)              
+    let cwd = (options && options.cwd ? options.cwd : this.kernel.homedir)   // if cwd exists, use it. Otherwise the cwd is pinokio home folder (~/pinokio)
     params.path = this.kernel.api.resolvePath(cwd, exec_path)
 
+    // If this shell runs under ~/pinokio/api/<workspace>, remember the workspace
+    // and the current set of known git repo roots so we can detect new repos
+    // created by this step and pin them to recorded commits.
+    let workspaceName
+    let workspaceRoot
+    let beforeDirs
+    if (params.path && this.kernel && this.kernel.path) {
+      const apiRoot = this.kernel.path("api")
+      const rel = path.relative(apiRoot, params.path)
+      if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+        const segments = rel.split(path.sep).filter(Boolean)
+        if (segments.length > 0) {
+          workspaceName = segments[0]
+          workspaceRoot = this.kernel.path("api", workspaceName)
+          beforeDirs = new Set(this.kernel.git.dirs)
+        }
+      }
+    }
+    const parentMeta = params.$parent || null
+
     const plannedShell = params.shell || (this.kernel.platform === 'win32' ? 'cmd.exe' : 'bash')
     await this.ensureBracketedPasteSupport(plannedShell)
     let sh = new Shell(this.kernel)
@@ -275,6 +295,15 @@ class Shells {
         sh.kill()
       }
     })
+    // If this shell ran under a workspace, rescan git repos for that workspace.
+    // Snapshots are now always user-initiated via the backups UI; here we only
+    // pin new repos to specific commits when this run was started from a
+    // snapshot restore.
+    if (workspaceRoot && beforeDirs) {
+      try {
+        await this.kernel.git.restoreNewReposForActiveSnapshot(workspaceName, workspaceRoot, beforeDirs)
+      } catch (_) {}
+    }
     /*
       {
         method: "shell.run",
@@ -450,11 +479,6 @@ class Shells {
       }
       return true
     } else {
-      const preview = typeof params.emit === 'string' ? params.emit.slice(0, 64) : ''
-      console.warn('[shell.emit] missing session for id', params.id, {
-        paste: !!params.paste,
-        preview
-      })
       return false
     }
   }

package/kernel/sysinfo.js

@@ -10,7 +10,8 @@ class Sysinfo {
 //    await this.refresh()
   }
   async static() {
-    await Promise.all([this.gpus(), this.system(), this.cpu(), this.os(), this.audio(), this.env()])
+    //await Promise.all([this.gpus(), this.system(), this.cpu(), this.os(), this.audio(), this.env()])
+    await Promise.all([this.gpus(), this.system(), this.cpu(), this.os(), this.audio(), this.env(), this.memory()])
 //    await this.gpus()
 //    await this.system()
 //    await this.cpu()
@@ -25,7 +26,8 @@ class Sysinfo {
 //    await this.time()
 
 
-    await Promise.all([this.memory(), this.battery(), this.proc(), this.bluetooth()])
+    //await Promise.all([this.memory(), this.battery(), this.proc(), this.bluetooth()])
+//    await Promise.all([this.memory(), this.proc()])
 //    await this.memory()
 //    await this.battery()
 //    await this.proc()
@@ -37,12 +39,13 @@ class Sysinfo {
   }
   async gpus() {
     let g = await system.graphics()
+    let controllers = Array.isArray(g && g.controllers) ? g.controllers : []
     let gpus
-    if (g && g.controllers && g.controllers.length > 0) {
-      gpus = g.controllers.map((x) => {
+    if (controllers.length > 0) {
+      gpus = controllers.map((x) => {
         return {
-          name: x.vendor.toLowerCase(),
-          model: x.model.toLowerCase()
+          name: (x.vendor || "").toLowerCase(),
+          model: (x.model || "").toLowerCase()
         }
       })
     } else {
@@ -71,11 +74,25 @@ class Sysinfo {
       gpu = "none"
     }
 
+    let primaryController
+    if (is_nvidia) {
+      primaryController = controllers.find(x => /nvidia/i.test(x.vendor || ""))
+    } else if (is_amd) {
+      primaryController = controllers.find(x => /(amd|advanced micro devices)/i.test(x.vendor || ""))
+    } else if (is_apple) {
+      primaryController = controllers.find(x => /apple/i.test(x.vendor || ""))
+    } else if (controllers.length > 0) {
+      primaryController = controllers[0]
+    }
+
+    let vramMB = primaryController && primaryController.vram ? primaryController.vram : 0
+    let vramGB = vramMB > 0 ? Math.round(vramMB / 1024) : 0
+
     this.info.graphics = g
     this.info.gpus = gpus
     this.info.gpu = gpu
     this.info.gpu_model = gpu_model
-
+    this.info.vram = vramGB
   }
 //  async time() {
 //    this.info.time = await system.time()
@@ -88,10 +105,13 @@ class Sysinfo {
   }
   async memory() {
     this.info.mem = await system.mem()
+    let totalBytes = this.info.mem && this.info.mem.total ? this.info.mem.total : 0
+    let totalGB = totalBytes > 0 ? Math.round(totalBytes / (1024 * 1024 * 1024)) : 0
+    this.info.ram = totalGB
   }
-  async battery() {
-    this.info.battery = await system.battery()
-  }
+//  async battery() {
+//    this.info.battery = await system.battery()
+//  }
   async os() {
     this.info.osInfo = await system.osInfo()
     this.info.shell = await system.shell()
@@ -113,9 +133,9 @@ class Sysinfo {
     this.info.gateway = await system.networkGatewayDefault()
     this.info.interface = await system.networkInterfaces("default")
   }
-  async bluetooth() {
-    this.info.bluetooth = await system.bluetoothDevices()
-  }
+//  async bluetooth() {
+//    this.info.bluetooth = await system.bluetoothDevices()
+//  }
   exists(_path) {
     return new Promise(r=>fs.access(_path, fs.constants.F_OK, e => r(!e)))
   }