pinokiod 3.41.0 → 3.42.0

package/kernel/api/browser/index.js

@@ -1,6 +1,8 @@
+const Util = require('../../util')
 class Browser {
   async open(req, ondata, kernel) {
-    ondata(req.params, "browser.open")
+    Util.openURL(req.params.uri)
+    //ondata(req.params, "browser.open")
   }
   async close(req, ondata, kernel) {
     ondata(req.params, "browser.close")

package/kernel/api/cloudflare/index.js

@@ -19,9 +19,9 @@ class C {
     let pipe_uri
     if (req.params.passcode) {
       // 1. start a pipe server => needed for authentication
-      const api_path = Util.api_path(req.parent.path, kernel)
-      const pinokio_path = path.resolve(api_path, "pinokio.js")
-      const config  = (await kernel.loader.load(pinokio_path)).resolved
+      const api_name = Util.api_name(req.parent.path, kernel)
+      const launcher = await kernel.api.launcher(api_name)
+      const config = launcher.script
       pipe_uri = await kernel.pipe.start(req.params.uri, req.parent.path, req.params.passcode, config)
     } else {
       // 2. if no passcode required, no need for a pipe server just use the original

package/kernel/api/index.js

@@ -28,6 +28,105 @@ class Api {
     this.child_procs = {}
     this.lproxy = new Lproxy()
   }
+  async launcher_path(name) {
+    let root_path = this.kernel.path("api", name)
+    let primary_path = path.resolve(root_path, "pinokio.js")
+    let exists = await this.exists(primary_path)
+    if (exists) {
+      return root_path
+    } else {
+      let secondary_path = path.resolve(root_path, "pinokio/pinokio.js")
+      let exists = await this.exists(secondary_path)
+      if (exists) {
+        return path.resolve(root_path, "pinokio")
+      }
+    }
+    // default is the 
+    return root_path
+  }
+  async launcher(name) {
+    /*
+      look for:
+      1. pinokio.js
+      2. ./pinokio/pinokio.js
+    */
+    let root_path
+    if (typeof name === "object") {
+      if (name.name) {
+        root_path = this.kernel.path("api", name.name)
+      } else if (name.path) {
+        root_path = name.path
+      }
+    } else {
+      root_path = this.kernel.path("api", name)
+    }
+    let primary_path = path.resolve(root_path, "pinokio.js")
+    let secondary_path = path.resolve(root_path, "pinokio/pinokio.js")
+    let pinokio = (await this.kernel.loader.load(primary_path)).resolved
+    let launcher_root = ""
+    if (!pinokio) {
+      pinokio = (await this.kernel.loader.load(secondary_path)).resolved
+      if (pinokio) {
+        launcher_root = "pinokio"
+      }
+    }
+    return {
+      script: pinokio,
+      root: root_path,
+      launcher_root
+    }
+  }
+//  async createMeta(formData) {
+//    let _path = this.kernel.path("api", formData.path)
+//    await fs.promises.mkdir(_path, { recursive: true }).catch((e) => {})
+//    let icon_path = this.kernel.path("api", formData.path, "icon.png")
+//    await fs.promises.writeFile(icon_path, formData.avatar)
+//
+//    // write title/description to pinokio.json
+//    let meta_path = this.kernel.path("api", formData.path, "pinokio.json")
+//    let meta = {
+//      title: formData.title,
+//      description: formData.description,
+//      icon: "icon.png",
+//      plugin: {
+//        menu: []
+//      }
+//    }
+//    await fs.promises.writeFile(meta_path, JSON.stringify(meta, null, 2))
+//  }
+  async updateMeta(formData, app_path) {
+    // write title/description to pinokio.json
+    let dirty
+    let launcher_path = await this.launcher_path(app_path)
+    let meta_path = path.resolve(launcher_path, "pinokio.json")
+    let meta = (await this.kernel.loader.load(meta_path)).resolved
+    if (!meta) meta = {}
+    if (formData.title) {
+      meta.title = formData.title
+      dirty = true
+    }
+    if (formData.description) {
+      meta.description = formData.description
+      dirty = true
+    }
+    if (!meta.plugin) {
+      meta.plugin = {
+        menu: []
+      }
+    }
+
+    if (formData.icon_dirty) {
+      // 
+      // write icon file
+      let icon_path = this.kernel.path("api", formData.new_path, formData.icon_path)
+      await fs.promises.writeFile(icon_path, formData.avatar)
+      meta.icon = formData.icon_path
+      dirty = true
+    }
+    if (dirty) {
+      await fs.promises.writeFile(meta_path, JSON.stringify(meta, null, 2))
+    }
+  }
   async meta(name) {
     let p1
     let p2
@@ -35,19 +134,19 @@ class Api {
     let api_path
     let api_name
     if (typeof name === "object") {
-      if (name.path) {
-        api_path = name.path
-        api_name = path.relative(this.kernel.path("api"), api_path)
-        p1 = path.resolve(name.path, "pinokio.js")
-        p2 = path.resolve(name.path, "pinokio_meta.json")
-        p3 = path.resolve(name.path, "pinokio.json")
-      }
+//      if (name.path) {
+//        api_path = name.path
+//        api_name = path.relative(this.kernel.path("api"), api_path)
+//        p1 = path.resolve(name.path, "pinokio.js")
+//        p2 = path.resolve(name.path, "pinokio_meta.json")
+//        p3 = path.resolve(name.path, "pinokio.json")
+//      }
     } else {
-      api_path = this.kernel.path("api", name)
+      api_path = await this.launcher_path(name)
       api_name = name
-      p1 = this.kernel.path("api", name, "pinokio.js")
-      p2 = this.kernel.path("api", name, "pinokio_meta.json")
-      p3 = this.kernel.path("api", name, "pinokio.json")
+      p1 = path.resolve(api_path, "pinokio.js")
+      p2 = path.resolve(api_path, "pinokio_meta.json")
+      p3 = path.resolve(api_path, "pinokio.json")
     }
     let pinokio = (await this.kernel.loader.load(p1)).resolved
     if (pinokio && pinokio.menu && !(Array.isArray(pinokio.menu) || typeof pinokio.menu === "function")) {
@@ -79,16 +178,23 @@ class Api {
 
     meta.iconpath = meta.icon ? meta.icon : null
     //meta.iconpath = meta.icon ? path.resolve(api_path, meta.icon) : null
-    meta.icon = meta.icon ? `/api/${api_name}/${meta.icon}?raw=true` : "/pinokio-black.png"
     meta.path = api_path
     meta.name = meta.title
-    //meta.link = `/pinokio/browser/${api_name}/dev#n1`
-    meta.link = `/p/${api_name}/dev#n1`
-    meta.web_path = `/api/${api_name}`
-    //meta.ui = `/pinokio/browser/${api_name}`
-    meta.ui = `/p/${api_name}`
-    //meta.browse = `/pinokio/browser/${api_name}/dev`
-    meta.browse = `/p/${api_name}/dev`
+
+    let relpath = path.relative(this.kernel.path("api", name), api_path)
+    if (relpath === ".") {
+      meta.icon = meta.icon ? `/asset/api/${api_name}/${meta.icon}` : "/pinokio-black.png"
+      meta.link = `/p/${api_name}/dev#n1`
+      meta.web_path = `/api/${api_name}`
+      meta.ui = `/p/${api_name}`
+      meta.browse = `/p/${api_name}/dev`
+    } else {
+      meta.icon = meta.icon ? `/asset/api/${api_name}/${meta.icon}` : "/pinokio-black.png"
+      meta.link = `/p/${api_name}/${relpath}/dev#n1`
+      meta.web_path = `/api/${api_name}/${relpath}`
+      meta.ui = `/p/${api_name}/${relpath}`
+      meta.browse = `/p/${api_name}/dev/${relpath}`
+    }
     if (!pinokio && !pinokio2 && !pinokio3 ) {
       meta.init_required = true
     }
@@ -264,32 +370,36 @@ class Api {
     } catch (e) {
     }
     if (files) {
-      let folders = files.filter((file) => { return file.isDirectory() }).map((folder) => { return folder.name })
+      let folders = []
+      for(let file of files) {
+        let type = await Util.file_type(this.userdir, file)
+        if (type.directory) {
+          folders.push(file.name)
+        } 
+      }
       for(let folder of folders) {
         try {
-          const configPath = path.resolve(this.userdir, folder, "pinokio.js")
-          let m = (await this.loader.load(configPath))
-          if (m.resolved) {
-            if (m.resolved.start) {
-              if (typeof m.resolved.start === "function") {
-                if (m.resolved.start.constructor.name === "AsyncFunction") {
-                  m.resolved.start = await m.resolved.start(this.kernel)
+          let m = await this.launcher(folder)
+          if (m && m.script) {
+            if (m.script.start) {
+              if (typeof m.script.start === "function") {
+                if (m.script.start.constructor.name === "AsyncFunction") {
+                  m.script.start = await m.script.start(this.kernel)
                 } else {
-                  m.resolved.start = m.resolved.start(this.kernel)
+                  m.script.start = m.script.start(this.kernel)
                 }
               }
               // start script name => turn into hex to find the folder
               // and add the path to the start script array
-              if (m.resolved.start) {
+              if (m.script.start) {
                 let uri = folder
                 startScripts.push({
                   name: folder,
                   path: "/api/" + folder,
                   uri,
-                  script: m.resolved
+                  script: m.script
                 })
               }
-
             }
           } 
         } catch (e) {
@@ -309,7 +419,13 @@ class Api {
     } catch (e) {
     }
     if (files) {
-      let folders = files.filter((file) => { return file.isDirectory() }).map((folder) => { return folder.name })
+      let folders = []
+      for(let file of files) {
+        let type = await Util.file_type(this.userdir, file)
+        if (type.directory) {
+          folders.push(file.name)
+        } 
+      }
       for(let folder of folders) {
         try {
           const repositoryPath = path.resolve(this.userdir, folder)
@@ -580,25 +696,31 @@ class Api {
   }
   async dirs(p) {
     const files = await fs.promises.readdir(p, { withFileTypes: true })
-    return files.filter(file => file.isDirectory()).map((x) => {
-      return {
-        name: x.name,
-        path: path.resolve(p, x.name)
-      }
-    });
+    let folders = []
+    for(let file of files) {
+      let type = await Util.file_type(this.userdir, file)
+      if (type.directory) {
+        folders.push({
+          name: file.name,
+          path: path.resolve(p, file.name)
+        })
+      } 
+    }
+    return folders
   }
   async files(p) {
     const files = await fs.promises.readdir(p, { withFileTypes: true })
-    return files.filter(file => !file.isDirectory())
-    .filter((file) => {
-      return !file.name.startsWith(".")  // no hidden files
-    })
-    .map((x) => {
-      return {
-        name: x.name,
-        path: path.resolve(p, x.name)
+    const res = []
+    for(let file of files) {
+      let type = await Util.file_type(this.userdir, file)
+      if (type.file && !file.name.startsWith(".")) {
+        res.push({
+          name: file.name,
+          path: path.resolve(p, file.name)
+        })
       }
-    });
+    }
+    return res
   }
   exists(_path) {
     return new Promise(r=>fs.access(_path, fs.constants.F_OK, e => r(!e)))
@@ -662,6 +784,8 @@ class Api {
 
     let { cwd, script } = await this.resolveScript(request.path)
 
+    let name = path.relative(this.kernel.path("api"), cwd)
+
     if (request.cwd) {
       cwd = request.cwd
     }
@@ -678,6 +802,7 @@ class Api {
       current: i,
       uri: request.uri,
       cwd,
+      name,
       self: script,
       port,
       ...this.kernel.vars,
@@ -798,7 +923,6 @@ class Api {
           } else {
             rpc.next = null
           }
-          console.log("next is not set. compute the next value", rpc.next)
         }
 
         if (rpc.hasOwnProperty("when")) {
@@ -1241,9 +1365,10 @@ class Api {
     })
   }
   async get_default(repo_path) {
-    let p = path.resolve(repo_path, "pinokio.js")
-    // call 'process' based on the current status
-    let config = (await this.loader.load(p)).resolved
+    let launcher = await this.launcher({
+      path: repo_path
+    })
+    let config = launcher.script
     if (config && config.menu) {
       if (typeof config.menu === "function") {
         if (config.menu.constructor.name === "AsyncFunction") {
@@ -1359,6 +1484,17 @@ class Api {
               this.done[request.path] = done
             }
 
+            // set DNS
+
+            if (request.path) {
+              if (request.path.startsWith(this.kernel.path("api"))) {
+                await this.kernel.dns({
+                  path: request.path
+                })
+              }
+            }
+
+
 
             this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
 

package/kernel/api/loading/index.js

@@ -0,0 +1,15 @@
+class Loading {
+  async start (req, ondata, kernel) {
+    ondata(req.params, "loading.start")
+    let response = await kernel.api.wait(req.parent.path)
+    console.log("loading.start response", response)
+    return response
+  }
+  async end (req, ondata, kernel) {
+    ondata(req.params, "loading.end")
+    let response = await kernel.api.wait(req.parent.path)
+    console.log("loading.end response", response)
+    return response
+  }
+}
+module.exports = Loading

package/kernel/api/process/index.js

@@ -215,9 +215,16 @@ class Process {
             this.resolve()
           }, ms)
         })
+      } else if (req.params.uri) {
+        let interval = req.params.interval ? req.params.interval * 1000 : 1000
+        ondata(req.params, "loading.start")
+        await waitForUrl(req.params.uri, req.params.message, interval, ondata)
+        ondata(req.params, "loading.end")
       } else if (req.params.url) {
         let interval = req.params.interval ? req.params.interval * 1000 : 1000
+        ondata(req.params, "loading.start")
         await waitForUrl(req.params.url, req.params.message, interval, ondata)
+        ondata(req.params, "loading.end")
       } else if (req.params.on) {
         // Wait
         if (req.params.message) {

package/kernel/api/shell/index.js

@@ -97,8 +97,6 @@ class Shell {
       req.params.$parent = req.parent
     }
 
-    console.log("#### shell.enter", req.params)
-
     let response = await kernel.shell.enter(req.params, ondata)
     //let response = await this.send(req, ondata, kernel, true)
     return response

package/kernel/bin/browserless.js

@@ -0,0 +1,22 @@
+class Browserless {
+  description = "The headless Chrome/Chromium driver"
+  async uninstall(req, ondata) {
+    await this.kernel.bin.exec({
+      message: "npm uninstall -g @browserless/cli"
+    }, ondata)
+  }
+  async install(req, ondata) {
+    await this.kernel.bin.exec({
+      message: "npm install -g @browserless/cli"
+    }, ondata)
+  }
+  async installed() {
+    let browserless = this.kernel.which('browserless')
+    if (browserless) {
+      return true
+    } else {
+      return false
+    }
+  }
+}
+module.exports = Browserless

package/kernel/bin/caddy.js

@@ -2,6 +2,7 @@ const axios = require('axios')
 const path = require('path')
 const fs = require('fs')
 const semver = require('semver')
+const kill = require('kill-sync')
 const Util = require('../util')
 
 class Caddy {
@@ -13,18 +14,24 @@ class Caddy {
     }
   }
   async running() {
-    console.log("caddy running check")
-    console.log("stack", new Error().stack)
     try {
       let response = await axios.get('http://127.0.0.1:2019/config/')
       return true
     } catch (e) {
-      console.log(e.message)
+//      console.log(e.message)
       return false
     }
   }
   async start() {
-//    console.log(">> proc", this.kernel.processes.caddy_pid, this.kernel.processes.info)
+//    console.log("Existing caddy pid?", this.kernel.processes.caddy_pid)
+    let running = await this.running()
+    console.log("Caddy running?", running)
+//    if (this.kernel.processes.caddy_pid) {
+    if (running) {
+      console.log("kill existing caddy")
+      kill(this.kernel.processes.caddy_pid, "SIGKILL", true)
+      console.log("killed existing caddy")
+    }
 //    let running = await this.running()
 //    console.log("Running", running)
 //    if (running) {
@@ -82,6 +89,19 @@ class Caddy {
         }
       })
     })
+
+    // wait until running
+    await new Promise((resolve, reject) => {
+      ondata({ raw: "waiting until caddy server is up...\r\n" })
+      setInterval(async () => {
+        let running = await this.running()
+        if (running) {
+          resolve()
+        }
+      }, 2000)
+    })
+    ondata({ raw: "caddy is running!\r\n" })
+
     if (this.kernel.platform === "win32") {
       await this.kernel.exec({
         message: `caddy trust`,
@@ -155,6 +175,18 @@ class Caddy {
       return false
     }
   }
+  async running() {
+    let running = false
+    try {
+      let res = await axios.get(`http://127.0.0.1:2019/config/`, {
+        timeout: 2000
+      })
+      running = true
+    } catch (e) {
+//      console.log(e)
+    }
+    return running
+  }
   async uninstall(req, ondata) {
     ondata({ raw: "cleaning up\r\n" })
     await this.kernel.bin.exec({

package/kernel/bin/index.js

@@ -210,7 +210,7 @@ class Bin {
         process.env.PLAYWRIGHT_BROWSERS_PATH = playwright_folder
       }
 //      await fs.promises.mkdir(playwright_folder, { recursive: true }).catch((e) => { })
-      let system_env = await Environment.get(this.kernel.homedir)
+      let system_env = await Environment.get(this.kernel.homedir, this.kernel)
 
       if (system_env.HTTP_PROXY) {
         process.env.HTTP_PROXY = system_env.HTTP_PROXY
@@ -1054,6 +1054,9 @@ class Bin {
 
     return {
       error,
+      title: config.bin.title,
+      description: config.bin.description,
+      icon: config.bin.icon,
       requirements,
       install_required,
       requirements_pending

package/kernel/bin/setup.js

@@ -49,6 +49,7 @@ module.exports = {
       { name: "huggingface" },
       { name: "uv" },
       { name: "py" },
+      { name: "browserless" },
     ])
     return {
       icon: "fa-solid fa-brain",
@@ -71,6 +72,7 @@ module.exports = {
       { name: "node", },
       { name: "cli", },
       { name: "py" },
+      { name: "browserless" },
     ])
     return {
       icon: "fa-brands fa-js",
@@ -110,6 +112,36 @@ module.exports = {
     }
   },
   dev: (kernel) => {
+    let requirements = [
+      { name: "conda", },
+      { name: "zip", },
+    ]
+    if (platform === "darwin") {
+      requirements.push({ name: "brew" })
+    }
+    requirements = requirements.concat([
+      { name: "git", },
+      { name: "node", },
+      { name: "cli", },
+      { name: "uv", },
+      { name: "py", },
+      { name: "browserless" },
+    ])
+    let conda_requirements = [
+      zip_cmd,
+      "uv",
+      "node",
+      "git",
+    ]
+    return {
+      icon: "fa-solid fa-laptop-code",
+      title: "Coding (Essential)",
+      description: "Install common modules required for development (Node.js, python, Visual Studio Developer Tools (Windows), Xcode build tools (Mac)",
+      requirements,
+      conda_requirements,
+    }
+  },
+  advanced_dev: (kernel) => {
     let requirements = [
       { name: "conda", },
       { name: "zip", },
@@ -123,12 +155,15 @@ module.exports = {
       { name: "cli", },
       { name: "uv", },
       { name: "caddy", },
+      { name: "huggingface" },
       { name: "py", },
+      { name: "browserless" },
     ])
     let conda_requirements = [
       zip_cmd,
       "uv",
       "node",
+      "huggingface",
       "git",
       "caddy",
     ]
@@ -136,17 +171,14 @@ module.exports = {
       requirements.push({ name: "registry" })
       requirements.push({ name: "vs" })
     }
-    if (platform === "darwin") {
-      requirements.push({ name: "brew" })
-    }
     if (platform === "linux") {
       requirements.push({ name: "gxx" })
       conda_requirements.push("gxx")
     }
     return {
       icon: "fa-solid fa-laptop-code",
-      title: "Coding",
-      description: "Install common modules required for development (Node.js, python, Visual Studio Developer Tools (Windows), Xcode build tools (Mac)",
+      title: "Coding (Advanced)",
+      description: "Coding (Essential) + More modules useful for building",
       requirements,
       conda_requirements,
     }
@@ -199,6 +231,7 @@ module.exports = {
       requirements,
       conda_requirements: [
         zip_cmd,
+        "huggingface",
         "uv",
         "git",
         "caddy"