pinokiod 3.6.29 → 3.6.30

package/server/index.js

@@ -28,6 +28,8 @@ const multer = require('multer');
 
 const ejs = require('ejs');
 
+const DEFAULT_PORT = 42000
+
 const ex = fn => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
 };
@@ -45,7 +47,8 @@ class Server {
   constructor(config) {
     this.tabs = {}
     this.agent = config.agent
-    this.port = config.port
+    this.port = DEFAULT_PORT
+//    this.port = config.port
     this.kernel = new Kernel(config.store)
 //    this.tunnels = {}
     this.version = {
@@ -83,30 +86,6 @@ class Server {
   exists (s) {
     return new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))
   }
-  winBuildNumber() {
-    let osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());
-    let buildNumber = 0;
-    if (osVersion && osVersion.length === 4) {
-        buildNumber = parseInt(osVersion[3]);
-    }
-    return buildNumber;
-  }
-  compatible() {
-    if (this.kernel.platform === "win32") {
-      let buildNumber = this.winBuildNumber() 
-      if (buildNumber < 18309) {
-        // must use conpty for node-pty, and conpty is only supported in win>=18309
-        console.log("Windows buildNumber", buildNumber)
-        throw new Error(`Pinokio supports Windows release 18309 and up (current system: ${buildNumber}`)
-      }
-
-//      if (buildNumber > 25000) {
-//        console.log("Windows buildNumber", buildNumber)
-//        throw new Error(`Pinokio does not currently support Windows Canary (versions 25000 and up). The current system is ${buildNumber}`)
-//        
-//      }
-    }
-  }
   getMemory(filepath) {
     let localMem = this.kernel.memory.local[filepath]
     let globalMem = this.kernel.memory.global[filepath]
@@ -142,7 +121,7 @@ class Server {
     return items.map((x) => {
       let name
       let description
-      let icon
+      let icon = "/pinokio-black.png"
       let uri
       if (meta) {
         let m = meta[x.name]
@@ -151,7 +130,8 @@ class Server {
         if (m && m.icon) {
           icon = m.icon
         } else {
-          icon = null
+          icon = "/pinokio-black.png"
+          //icon = null
         }
         uri = x.name
       } else {
@@ -191,6 +171,60 @@ class Server {
       }
     })
   }
+  async init_shells(dir) {
+    let current = this.kernel.path(dir, "SHELLS")
+    let exists = await this.exists(current)
+    if (exists) {
+      // SHELLS folder exists, skip
+    } else {
+      // if SHELLS doesn't exist, need to create one
+      // 1. if _SHELLS exists, create SHELLS by copying the contents of _SHELLS into SHELLS
+      // 2. if _SHELLS doesn't exist, just write SHELLS
+      // if _ENVIRONMENT exists, 
+      let _shells = this.kernel.path(dir, "_SHELLS")
+      let _dest_shells = this.kernel.path(dir, "SHELLS")
+      await fs.promises.mkdir(_dest_shells).catch((e) => { })
+
+      // write _.json
+      let defaultShell = path.resolve(_dest_shells, "_.json")
+      let default_shell_exists = await this.exists(_shells)
+      if (!default_shell_exists) {
+        await fs.promises.writeFile(defaultShell, JSON.stringify({
+          run: [{
+            method: "shell.run",
+            params: {
+              message: [
+                "npm install -g @anthropic-ai/claude-code",
+              ],
+            }
+          }, {
+            method: "shell.run",
+            params: {
+              message: [
+                "claude"
+              ],
+              input: true
+            }
+          }]
+        }, null, 2))
+      }
+
+      let _exists = await this.exists(_shells)
+      if (_exists) {
+        let files = await fs.promises.readdir(_shells)
+        for(let file of files) {
+          try {
+            let src = path.resolve(_shells, file)
+            let dest = path.resolve(_dest_shells, file)
+            await fs.promises.cp(src, dest, { errorOnExist: true, force: false });
+          } catch (err) {
+          }
+        }
+//      } else {
+//        await fs.cp(_shells, _dest_shells, { recursive: true });
+      }
+    }
+  }
   async init_env(env_dir_path, options) {
     let current = this.kernel.path(env_dir_path, "ENVIRONMENT")
       // if environment.json doesn't exist, 
@@ -298,6 +332,12 @@ class Server {
     }
     let platform = os.platform()
 
+    if (config.icon) {
+      config.icon = `${rawpath}/${config.icon}?raw=true`
+    } else {
+      config.icon = "/pinokio-black.png"
+    }
+
 
     // get all memory variable stied to the current repository
     let api_path = this.kernel.path("api", name)
@@ -320,6 +360,7 @@ class Server {
 
     await this.init_env("api/" + name)
 
+    await this.init_shells("api/" + name)
 
     let mode = "run"
     if (req.query && req.query.mode) {
@@ -327,7 +368,34 @@ class Server {
     }
     const env = await this.kernel.env("api/" + name)
 
+    let shell_path = this.kernel.path("api", name, "SHELLS")
+    let shells = []
+    try {
+      shells = await fs.promises.readdir(shell_path)
+      shells = shells.filter((s) => {
+        return s.endsWith(".json")
+      })
+
+      let s = []
+      for(let shell of shells) {
+        try {
+          let p = path.resolve(shell_path, shell)
+          console.log("3p", p)
+          let json = (await this.kernel.loader.load(p)).resolved
+          console.log(">>", { json })
+          if (json && json.run && Array.isArray(json.run)) {
+            s.push(`/api/${name}/SHELLS/${shell}`)
+          }
+        } catch (e) {
+        }
+      }
+      shells = s
+    } catch (e) {
+    }
+    console.log({ shells })
+
     res.render("app", {
+      shells,
       error,
       env,
       mode,
@@ -479,84 +547,8 @@ class Server {
         display: ["form"]
       })
     } else if (pathComponents.length === 0 && req.query.mode === "download") {
-
-      let requirements = [{
-        name: "conda",
-      }, {
-        name: "git",
-      }, {
-        name: "zip",
-      }, {
-        name: "node",
-      }, {
-        name: "ffmpeg",
-//        type: "conda",
-//        name: "ffmpeg",
-//        args: "-c conda-forge"
-      }]
-      let platform = os.platform()
-      if (platform === "win32") {
-        requirements.push({
-          name: "registry"
-        })
-        requirements.push({
-          name: "vs"
-        })
-      }
-      if (platform === "darwin") {
-        requirements.push({
-          name: "brew"
-        })
-      }
-      if (platform === "linux") {
-        requirements.push({
-          name: "gxx"
-        })
-      }
-      if (this.kernel.gpu === "nvidia") {
-        requirements.push({
-          name: "cuda",
-        })
-      }
-      requirements = requirements.concat([{
-        name: "py"
-      }, {
-        name: "cloudflared"
-      }, {
-        name: "playwright"
-      }, {
-        name: "huggingface"
-      }, {
-        name: "uv"
-      }])
-
-      let requirements_pending = !this.kernel.bin.installed_initialized
-
-
-      let install_required = true
-      if (!requirements_pending) {
-        install_required = false
-        for(let i=0; i<requirements.length; i++) {
-          let r = requirements[i]
-          console.time(r.name)
-          let installed = await this.installed(r)
-          console.log({ r, installed })
-          console.timeEnd(r.name)
-          requirements[i].installed = installed
-          if (!installed) {
-            install_required = true
-          }
-        }
-      }
-
-      let error = null
-      try {
-        this.compatible()
-      } catch (e) {
-        error = e.message
-        install_required = true
-      }
-
+      let { requirements, install_required, requirements_pending, error } = await this.kernel.bin.check_bin()
+      console.log({ requirements, install_required, requirements_pending })
 
       res.render("download", {
         error,
@@ -916,7 +908,7 @@ class Server {
 
         let error = null
         try {
-          this.compatible()
+          this.kernel.bin.compatible()
         } catch (e) {
           error = e.message
           install_required = true
@@ -1278,7 +1270,7 @@ class Server {
         //let name = (x.name.startsWith("0x") ? Buffer.from(x.name.slice(2), "hex").toString() : x.name)
         let name
         let description
-        let icon
+        let icon = "/pinokio-black.png"
         let uri
         if (meta) {
           let m = meta[x.name]
@@ -1287,7 +1279,8 @@ class Server {
           if (m && m.icon) {
             icon = m.icon
           } else {
-            icon = null
+            //icon = null
+            icon = "/pinokio-black.png"
           }
           uri = x.name
         } else {
@@ -1886,76 +1879,76 @@ class Server {
     // 5. existing home is NOT set + new home is set => go through with the "home" setting procedure
     // 6. existing home is NOT set + new home is NOT set => don't touch anything => the homedir will be the default home
 
-    // 2. HOME
-    // 2.1. Check if the config includes NEW_HOME => if so,
-    //    - move the HOME folder to NEW_HOME
-    //    - set HOME=NEW_HOME
-    //    - remove NEW_HOME
-    let existing_home = this.kernel.store.get("home")
-    let new_home = this.kernel.store.get("new_home")
-
-    if (existing_home) {
-      let exists = await fse.pathExists(existing_home)
-      if (exists) {
-        if (new_home) {
-          let new_home_exists = await fse.pathExists(new_home)
-          if (new_home_exists) {
-            // - existing home is set
-            // - existing home exists
-            // - new home is set
-            // - new home exists already
-            //    => delete store.new_home ==> will load at store.home
-            this.kernel.store.delete("new_home")
-          } else {
-            // - existing home is set
-            // - existing home exists
-            // - new home is set
-            // - new home does not exist
-            //    => run mv()
-            //    => update store.home
-            //    => delete store.new_home
-            await this.mv(existing_home, new_home)
-            this.kernel.store.set("home", new_home)
-            this.kernel.store.delete("new_home")
-          }
-        } else {
-          // - existing home is set
-          // - existing home exists
-          // - new home is not set
-          //    => This is most typical scenario => don't touch anything => the homedir will be the existing home
-        }
-      } else {
-        if (new_home) {
-          // - existing home is set
-          // - but the existing home path DOES NOT exist
-          // - new home is set
-          //    => This is an invalid scenario => Just to avoid disaster, just delete store.home and delete store.new_home
-          //    => the app will load at ~/pinokio
-          this.kernel.store.delete("home")
-          this.kernel.store.delete("new_home")
-        } else {
-          // - existing home is set
-          // - but the existing home path DOES NOT exist
-          // - new home is NOT set
-          //    => This is an invalid scenario => just delete store.home
-          //    => the app will load at ~/pinokio
-          this.kernel.store.delete("home")
-        }
-      }
-    } else {
-      if (new_home) {
-        // - existing home is NOT set
-        // - new home is set
-        //    => update store.home
-        //    => delete store.new_home
-        this.kernel.store.set("home", new_home)
-        this.kernel.store.delete("new_home")
-      } else {
-        // - existing home is NOT set
-        // - new home is NOT set
-        //    => don't touch anything => will load at ~/pinokio
-      }
-    }
+//    // 2. HOME
+//    // 2.1. Check if the config includes NEW_HOME => if so,
+//    //    - move the HOME folder to NEW_HOME
+//    //    - set HOME=NEW_HOME
+//    //    - remove NEW_HOME
+//    let existing_home = this.kernel.store.get("home")
+//    let new_home = this.kernel.store.get("new_home")
+//
+//    if (existing_home) {
+//      let exists = await fse.pathExists(existing_home)
+//      if (exists) {
+//        if (new_home) {
+//          let new_home_exists = await fse.pathExists(new_home)
+//          if (new_home_exists) {
+//            // - existing home is set
+//            // - existing home exists
+//            // - new home is set
+//            // - new home exists already
+//            //    => delete store.new_home ==> will load at store.home
+//            this.kernel.store.delete("new_home")
+//          } else {
+//            // - existing home is set
+//            // - existing home exists
+//            // - new home is set
+//            // - new home does not exist
+//            //    => run mv()
+//            //    => update store.home
+//            //    => delete store.new_home
+//            await this.mv(existing_home, new_home)
+//            this.kernel.store.set("home", new_home)
+//            this.kernel.store.delete("new_home")
+//          }
+//        } else {
+//          // - existing home is set
+//          // - existing home exists
+//          // - new home is not set
+//          //    => This is most typical scenario => don't touch anything => the homedir will be the existing home
+//        }
+//      } else {
+//        if (new_home) {
+//          // - existing home is set
+//          // - but the existing home path DOES NOT exist
+//          // - new home is set
+//          //    => This is an invalid scenario => Just to avoid disaster, just delete store.home and delete store.new_home
+//          //    => the app will load at ~/pinokio
+//          this.kernel.store.delete("home")
+//          this.kernel.store.delete("new_home")
+//        } else {
+//          // - existing home is set
+//          // - but the existing home path DOES NOT exist
+//          // - new home is NOT set
+//          //    => This is an invalid scenario => just delete store.home
+//          //    => the app will load at ~/pinokio
+//          this.kernel.store.delete("home")
+//        }
+//      }
+//    } else {
+//      if (new_home) {
+//        // - existing home is NOT set
+//        // - new home is set
+//        //    => update store.home
+//        //    => delete store.new_home
+//        this.kernel.store.set("home", new_home)
+//        this.kernel.store.delete("new_home")
+//      } else {
+//        // - existing home is NOT set
+//        // - new home is NOT set
+//        //    => don't touch anything => will load at ~/pinokio
+//      }
+//    }
   }
   async setConfig(config) {
     let home = this.kernel.store.get("home")
@@ -1980,13 +1973,14 @@ class Server {
           throw new Error("Invalid path: " + config.home)
         }
 
-        // check if the destination already exists => throw error
-        let exists = await fse.pathExists(config.home)
-        if (exists) {
-          throw new Error(`The path ${config.home} already exists. Please remove the folder and retry`)
-        }
+//        // check if the destination already exists => throw error
+//        let exists = await fse.pathExists(config.home)
+//        if (exists) {
+//          throw new Error(`The path ${config.home} already exists. Please remove the folder and retry`)
+//        }
 
-        this.kernel.store.set("new_home", config.home)
+        //this.kernel.store.set("new_home", config.home)
+        this.kernel.store.set("home", config.home)
       }
 
     }
@@ -2015,7 +2009,6 @@ class Server {
 
     home = this.kernel.store.get("home")
     theme = this.kernel.store.get("theme")
-    let new_home = this.kernel.store.get("new_home")
   }
   async startLogging(homedir) {
     console.log(">>>>>>> startLogging", homedir)
@@ -2052,7 +2045,27 @@ class Server {
       }
     }
   }
+  async running(port) {
+    let p = port || DEFAULT_PORT
+    const available = await Util.is_port_available(p)
+    if (available) {
+      return false
+    } else {
+      return true
+    }
+  }
   async start(options) {
+    console.time("###### ALL")
+
+//    // ONLY start if not already running
+//    let is_running = await this.running(this.port || DEFAULT_PORT)
+//    if (is_running) {
+//      console.log("pinokiod already running, skip..")
+//      return
+//    }
+//
+
+    console.time("######### 1")
     this.debug = false
     if (options) {
       this.debug = options.debug
@@ -2084,10 +2097,14 @@ class Server {
 //      } catch (e) {
 //      }
     }
+    console.timeEnd("######### 1")
 
     // configure from kernel.store
+    console.time("###### 2 syncConfig")
     await this.syncConfig()
+    console.timeEnd("###### 2 syncConfig")
 
+    console.time("###### 3 startLogging")
     try {
       let _home = this.kernel.store.get("home")
       console.log({ _home })
@@ -2097,11 +2114,12 @@ class Server {
     } catch (e) {
       console.log("start logging attempt", e)
     }
+    console.timeEnd("###### 3 startLogging")
 
     // determine port if port is not passed in
 
     if (!this.port) {
-      this.port = 42000
+      this.port = DEFAULT_PORT
 //      let platform = os.platform()
 //      if (platform === 'linux') {
 //        // on linux you are not allowed to listen on ports below 1024
@@ -2151,15 +2169,19 @@ class Server {
         console.log("[DONE] Updating to the new version")
       }
     }
-
+    console.time("###### 4 kernel.init")
     // initialize kernel
     await this.kernel.init({ port: this.port})
+    console.timeEnd("###### 4 kernel.init")
 
     console.log({ needInitHome })
+    console.time("###### 5 initHome")
     if (needInitHome) {
       await this.kernel.initHome()
     }
+    console.timeEnd("###### 5 initHome")
 
+    console.time("###### 6")
     if (this.kernel.homedir) {
       let ex = await this.kernel.exists(this.kernel.homedir, "ENVIRONMENT")
       if (!ex) {
@@ -2167,6 +2189,7 @@ class Server {
         await fs.promises.writeFile(path.resolve(this.kernel.homedir, "ENVIRONMENT"), str)
       }
     }
+    console.timeEnd("###### 6")
 
 
 
@@ -2251,6 +2274,7 @@ class Server {
     
 
     //await this.configure()
+    console.time("###### 7")
 
     this.started = false
     this.app = express();
@@ -2497,6 +2521,20 @@ class Server {
       let str = await fs.promises.readFile(req.query.logpath, "utf8")
       res.send(str)
     }))
+    this.app.post("/mkdir", ex(async (req, res) => {
+      let folder = req.body.folder
+      let folder_path = path.resolve(this.kernel.api.userdir, req.body.folder)
+      try {
+        await fs.promises.mkdir(folder_path)
+        res.json({
+          success: "/pinokio/browser/"+folder
+        })
+      } catch (e) {
+        res.json({
+          error: e.message
+        })
+      }
+    }))
     this.app.post("/proxy", ex(async (req, res) => {
       /*
         req.body := {
@@ -2634,6 +2672,8 @@ class Server {
       }
       if (config.icon) {
         config.icon = `/${env_path}/${config.icon}?raw=true`
+      } else {
+        config.icon = "/pinokio-black.png"
       }
 
       let name
@@ -2694,6 +2734,8 @@ class Server {
         config.pre.forEach((item) => {
           if (item.icon) {
             item.icon = `/api/${req.params.name}/${item.icon}?raw=true`
+          } else {
+            item.icon = "/pinokio-black.png"
           }
           if (!item.href.startsWith("http")) {
             item.href = path.resolve(this.kernel.homedir, "api", req.params.name, item.href)
@@ -2802,6 +2844,43 @@ class Server {
       }
       res.json({ config: this.xterm })
     }))
+//    this.app.get("/shell", ex(async (req, res) => {
+//      console.log("req.query", req.query)
+//      res.render("terminal", {
+//        memory: [],
+//        logo: this.logo,
+//        theme: this.theme,
+//        run: true,
+//        stop: false,
+//        runnable: true,
+//        agent: this.agent,
+////        uri,
+//        mod: true,
+//        json: true,
+//        js: false,
+//        install_required: false,
+//        current: req.originalUrl,
+//      })
+//    }))
+    this.app.get("/shells/:name", ex(async (req, res) => {
+      let p = this.kernel.path("api", req.params.name)
+      let venv_folders = await Util.find_venv(p)
+      console.log({ venv_folders })
+      let items = venv_folders.map((f) => {
+        let args = {
+          message: "",
+          venv: f
+        }
+        return {
+          name: f,
+          cmd: new URLSearchParams(args).toString()
+        }
+      })
+      console.log({ items })
+      res.json({
+        items
+      })
+    }))
     this.app.get("/du/:name", ex(async (req, res) => {
       let p = this.kernel.path("api", req.params.name)
       let d1 = await Util.du(p)
@@ -3421,6 +3500,8 @@ class Server {
     // install
     this.server = httpserver.createServer(this.app);
     this.socket = new Socket(this)
+    console.timeEnd("###### 7")
+    console.time("###### 8")
     await new Promise((resolve, reject) => {
       this.listening = this.server.listen(this.port, () => {
         console.log(`Server listening on port ${this.port}`)
@@ -3430,6 +3511,8 @@ class Server {
         server: this.listening
       });
     })
+    console.timeEnd("###### 8")
+    console.timeEnd("###### ALL")
 
   }
 }

package/server/public/style.css

@@ -1701,6 +1701,11 @@ footer.status {
   text-transform: uppercase;
 }
 
+#fsmenu {
+  background: rgba(0,0,100,0.04);
+  display: flex;
+  padding: 20px 20px 0;
+}
 mark{
   background: firebrick;
   color: white;