pinokiod 3.9.0 → 3.9.3

package/kernel/api/filepicker/index.js

@@ -0,0 +1,59 @@
+const path = require('path')
+const { spawn } = require("child_process");
+/*
+{
+  method: "filepicker.open",
+  params: {
+    title,             := <dialog title>
+    type,              := folder | file (default)
+    cwd,               := <cwd to open from>
+    filetypes,         := <file types to accept> (example:   [["Images", "*.png *.jpg *.jpeg"]] )
+    multiple,          := True | False (allow multiple)
+    save,              := True | False ('save as' dialog, which lets the user select a file name)
+    initialfile,       := In case of "save=True", set the default filename
+    confirmoverwrite,  := True | False (if set to true, will warn if the selected file name exists, for save=True type dialogs)
+  }
+}
+
+
+returns an array of selected file paths
+
+returns: {
+  paths: [
+    ...,
+    ....
+  ]
+}
+
+*/
+class Filepicker {
+  async open(req, ondata, kernel) {
+    if (req.params.cwd) {
+      req.params.cwd = path.resolve(req.cwd, req.params.cwd)
+    } else {
+      req.params.cwd = req.cwd
+    }
+    let response = await new Promise((resolve, reject) => {
+      let picker_path = kernel.path("bin/py/picker.py")
+      const proc = spawn("python", [picker_path])
+
+      let output = "";
+      proc.stdout.on("data", (chunk) => output += chunk);
+      proc.stderr.on("data", (err) => console.error("Python error:", err.toString()));
+      proc.on("close", () => {
+        try {
+          const result = JSON.parse(output);
+          if (result.error) return reject(result.error);
+          resolve(result.paths); // Always an array
+        } catch (e) {
+          reject("Failed to parse Python output: " + output);
+        }
+      });
+
+      proc.stdin.write(JSON.stringify(req.params));
+      proc.stdin.end();
+    });
+    return { paths: response }
+  }
+}
+module.exports = Filepicker

package/kernel/api/fs/index.js

@@ -75,16 +75,18 @@ class FS {
     /*
       params := {
         path: <filepath>,
-        mode: "view(default)|open"
+        command: "view(default)|open|<any command in PATH>"
       }
       open finder/file explorer at path
     */
     let dirPath = path.resolve(req.cwd, req.params.path)
     ondata({ raw: `\r\nopening path: ${dirPath}\r\n` })
-    if (req.params.mode) {
-      Util.openfs(dirPath, req.params.mode)
+    if (req.params.command) {
+      Util.openfs(dirPath, req.params, kernel)
+    } else if (req.params.mode) {
+      Util.openfs(dirPath, req.params, kernel)
     } else {
-      Util.openfs(dirPath)
+      Util.openfs(dirPath, {}, kernel)
     }
   }
 

package/kernel/api/index.js

@@ -28,6 +28,21 @@ class Api {
     this.child_procs = {}
     this.lproxy = new Lproxy()
   }
+  async meta(name) {
+    let p = this.kernel.path("api", name, "pinokio.js")
+    let pinokio = (await this.kernel.loader.load(p)).resolved
+    let p2 = this.kernel.path("api", name, "pinokio_meta.json")
+    let pinokio2 = (await this.kernel.loader.load(p2)).resolved
+    let p3 = this.kernel.path("api", name, "pinokio.json")
+    let pinokio3 = (await this.kernel.loader.load(p3)).resolved
+    let meta = Object.assign({}, pinokio, pinokio2, pinokio3)
+    meta.iconpath = meta.icon ? this.kernel.path("api", name, meta.icon) : null
+    meta.icon = meta.icon ? `/api/${name}/${meta.icon}?raw=true` : "/pinokio-black.png"
+    meta.path = this.kernel.path("api", name)
+    meta.name = meta.title
+    meta.link = `/pinokio/browser/${name}/browse#n1`
+    return meta
+  }
   get_proxy_url(root, port) {
     if (this.proxies) {
       let proxies = this.proxies[root]
@@ -124,16 +139,12 @@ class Api {
 
     let requestPath = this.filePath(req.params.uri)
 
-
-
     let { cwd, script } = await this.resolveScript(requestPath)
-    console.log("STOP", { script })
     if (script.on) {
       if (script.on.stop) {
         await this.process(script.on.stop) 
       }
     }
-
     // reset modules
     let modpath = this.resolvePath(cwd, req.params.uri)
     console.log("STOP modpath", modpath)
@@ -179,6 +190,7 @@ class Api {
       id: requestPath,
       type: "disconnect"
     })
+    this.kernel.refresh(true)
     return true
   }
   async startScripts() {
@@ -352,13 +364,20 @@ class Api {
     let modpath
     if (matched_repo.length > 0) {
       let repo_uri = matched_repo[0]
-
-      let relative_path = uri
-        .replace(repo_uri, "")    // remove the git repo uri
-        .slice(1)                 // remove the leading '/' for relative path
+      if (!repo_uri.endsWith(".git")) {
+        repo_uri = repo_uri + ".git"
+      }
 
       let repopath = this.gitPath[repo_uri]
-      modpath = path.resolve(repopath, relative_path)
+      if (uri === repo_uri) {
+        modpath = path.resolve(repopath)
+      } else {
+        let relative_path = uri
+          .replace(repo_uri, "")    // remove the git repo uri
+          .slice(1)                 // remove the leading '/' for relative path
+        modpath = path.resolve(repopath, relative_path)
+      }
+
     } else {
       //console.log("no matching gitpath")
     }
@@ -426,14 +445,18 @@ class Api {
     let method
     let dirname
     let mod
-    if (req.uri) {
+    if (req.method && typeof req.method === "function") {
+      modpath = null
+      method = req.method
+      dirname = __dirname
+      mod = null
+    } else if (req.uri) {
       modpath = this.resolvePath(cwd, req.uri)
       let m = (await this.loader.load(modpath))
       const stats = await fs.promises.stat(modpath)
       if (!this.child_procs[req.parent.path]) {
         this.child_procs[req.parent.path] = new Set()
       }
-      console.log("SCRIPT RESOLVE METHOD", req)
       if (this.mods[modpath]) {
         // use the cached module if unchanged
         if (String(stats.mtime) === String(this.mods[modpath].updated)) {
@@ -567,15 +590,19 @@ class Api {
 
   }
   async step (request, rawrpc, input, i, total, args) {
-    console.time("STEP INIT")
     await Promise.all([this.init(), this.kernel.update_sysinfo()])
-    console.timeEnd("STEP INIT")
 
     // clear global regular expression object RegExp.lastMatch (memory leak prevention)
     let r = /\s*/g.exec("");
 
+    let port = await this.kernel.port()
+
     let { cwd, script } = await this.resolveScript(request.path)
 
+    if (request.cwd) {
+      cwd = request.cwd
+    }
+
     let memory = {
       script: this.kernel.script,
       input,
@@ -587,6 +614,7 @@ class Api {
       uri: request.uri,
       cwd,
       self: script,
+      port,
       ...this.kernel.vars,
     }
 
@@ -627,7 +655,6 @@ class Api {
         break;
       }
     }
-
     // replace {{{ }}} with {{ }}
     rpc = this.kernel.template.flatten(rpc)
 
@@ -761,6 +788,7 @@ class Api {
                     uri: request.path
                   }
                 })
+                console.log(">>>>>> STOPPED", request)
               }
               return { request, input: null, step: rpc.next, total: script.run.length, args }
             } else {
@@ -979,6 +1007,7 @@ class Api {
                   uri: request.path
                 }
               })
+              console.log("<<<<<< STOPPED", request)
               return { request, input: result, step: rpc.next, total: script.run.length, args }
             }
 
@@ -1056,6 +1085,7 @@ class Api {
             })
           }
         }
+        this.kernel.refresh(true)
       } catch (e) {
         ondata({ raw: e.toString() })
       }
@@ -1121,6 +1151,35 @@ class Api {
       this.process(request, resolve)
     })
   }
+  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
+    if (config && config.menu) {
+      if (typeof config.menu === "function") {
+        if (config.menu.constructor.name === "AsyncFunction") {
+          config.menu = await config.menu(this.kernel, this.kernel.info)
+        } else {
+          config.menu = config.menu(this.kernel, this.kernel.info)
+        }
+      }
+      // find the default item in the menu
+      let running = config.menu.filter((item) => {
+        return item.default
+      })
+      if (running.length > 0) {
+        let r = running[0]
+        if (r.href) {
+          if (r.href.startsWith("http")) {
+            return r.href
+          } else {
+            let href = path.resolve(repo_path, r.href)
+            return href
+          }
+        }
+      }
+    }
+  }
   async process(request, done) {
     /**************************************************************
     *
@@ -1162,43 +1221,66 @@ class Api {
 //    this.kernel.keys = (await this.loader.load(keypath)).resolved
 
     // init shell before running just to make sure the environment variables are fresh
-    console.time("shell.init")
     await this.kernel.shell.init()
-    console.timeEnd("shell.init")
 
     if (request.uri){
+
       this.counter++;
       // API Call
 
       request.path = this.resolvePath(this.userdir, request.uri)
-      let { cwd, script } = await this.resolveScript(request.path)
-      request.cwd = cwd
-
-      if (!script) {
-        this.ondata({
-          id: request.path,
-          type: "error",
-          data: "the endpoint does not exist: " + request.uri,
-        })
-      } else {
-        // 3. Check if the resolved endpoint has the "run" attribute and it's an array
-        //if (script.run && Array.isArray(script.run)) {
-        if (script.run) {
-
-          this.running[request.path] = true
-
-          this.done[request.path] = done
 
-          this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
 
+      // if the path is 
+      let relative = path.relative(this.kernel.homedir, request.path)
+      let chunks = relative.split(path.sep)
+      console.log({ chunks })
+      if (chunks.length == 2) {
+        // the script is requesting a uri of the git repo
+        // look for pinokio.js
+        let p = path.resolve(request.path, "pinokio.js")
+        let exists = await this.exists(p)
+        console.log({ p, exists })
+        if (exists) {
+          await this.launch(request, p)
         } else {
           this.ondata({
             id: request.path,
             type: "error",
-            data: "missing attribute: run"
+            data: "uri doesn't exist \r\n" + JSON.stringify(request, null, 2)
+          })
+        }
+      } else {
+        console.log({ request })
+        let { cwd, script } = await this.resolveScript(request.path)
+
+        if (!script) {
+          this.ondata({
+            id: request.path,
+            type: "error",
+            data: "the endpoint does not exist: " + request.uri,
           })
+        } else {
+          // 3. Check if the resolved endpoint has the "run" attribute and it's an array
+          //if (script.run && Array.isArray(script.run)) {
+          if (script.run) {
+
+            this.running[request.path] = true
+
+            this.done[request.path] = done
+
+            this.queue(request, script.run[0], request.input, 0, script.run.length, cwd, request.input)
+
+          } else {
+            this.ondata({
+              id: request.path,
+              type: "error",
+              data: "missing attribute: run"
+            })
+          }
         }
       }
+
     } else if (request.method) {
       let pass = 0;
       while(true) {
@@ -1229,12 +1311,16 @@ class Api {
 
       // Kernel Call
       let resolved = await this.resolveMethod(request)
+      let id = request.id ? request.id : request.method 
+      if (request.id) {
+        this.running[request.id] = true
+      }
       try {
         resolved.dirname = resolved.dirname
         let result = await this.run(resolved.method, request, (stream, type) => {
           this.ondata({
             kernel: true,
-            id: request.method,
+            id,
             type: (type ? type : "stream"),
             data: stream,
             rpc: request,
@@ -1243,7 +1329,7 @@ class Api {
         })
         this.ondata({
           kernel: true,
-          id: request.method,
+          id,
           type: "result",
           data: result,
           rpc: request,

package/kernel/api/input/index.js

@@ -1,5 +1,7 @@
 module.exports = async (req, ondata, kernel) => {
+  // send "input" type event so the frontend triggers a modal
   ondata(req.params, "input")
+  // then, wait until the frontend responds
   let response = await kernel.api.wait(req.parent.path)
   return response
 }

package/kernel/api/web/index.js

@@ -21,5 +21,11 @@ class Web {
     kernel.exposed[app] = req.params.uri
     console.log("kernel.exposed", kernel.exposed)
   }
+  async open(req, ondata, kernel) {
+    ondata(req.params, "browser.open")
+  }
+  async close(req, ondata, kernel) {
+    ondata(req.params, "browser.close")
+  }
 }
 module.exports = Web

package/kernel/bin/caddy.js

@@ -0,0 +1,127 @@
+const axios = require('axios')
+const fs = require('fs')
+
+class Caddy {
+  cmd() {
+    if (this.kernel.platform === "win32") {
+      return "caddy"
+    } else {
+      return "caddy nss"
+    }
+  }
+  async running() {
+    console.log("caddy running check")
+    try {
+      let response = await axios.get('http://127.0.0.1:2019/config/')
+      return true
+    } catch (e) {
+      console.log(e.message)
+      return false
+    }
+  }
+  async start() {
+//    console.log(">> proc", this.kernel.processes.caddy_pid, this.kernel.processes.info)
+//    let running = await this.running()
+//    console.log("Running", running)
+//    if (running) {
+//      // kill first
+//      return
+//    } 
+    let installed = await this.installed()
+    console.log("Caddy Installed?", installed)
+    if (installed) {
+      let resolved
+      await new Promise((resolve, reject) => {
+        this.kernel.exec({
+          message: `caddy run --watch`,
+          path: this.kernel.homedir,
+        }, (e) => {
+          if (!resolved) {
+            if (/endpoint started/i.test(e.cleaned)) {
+              console.log("######### match")
+              resolved = true
+              resolve()
+            }
+          }
+        })
+      })
+      this.kernel.refresh(true)
+    }
+  }
+  async install(req, ondata, kernel, id) {
+    await this.kernel.bin.exec({
+      message: [
+        "conda clean -y --all",
+        `conda install -y -c conda-forge ${this.cmd()}`
+      ]
+    }, ondata)
+    let resolved
+    await new Promise((resolve, reject) => {
+      this.kernel.exec({
+        message: `caddy run --watch`,
+        path: this.kernel.homedir,
+      }, (e) => {
+        resolve()
+        if (!resolved) {
+          if (/endpoint started/i.test(e.cleaned)) {
+            console.log("######### match")
+            resolved = true
+            resolve()
+          }
+        }
+      })
+    })
+    if (this.kernel.platform === "win32") {
+      await this.kernel.exec({
+        message: `caddy trust`,
+        path: this.kernel.homedir
+      }, (e) => {
+        ondata(e)
+      })
+    } else {
+      ondata({
+        title: "Password",
+        description: "Enter your system password to add the HTTPS certificate",
+        form: [{
+          type: "password",
+          autofocus: true,
+          key: "password",
+          placeholder: "System password",
+        }]
+      }, "input")
+      let response = await this.kernel.api.wait(id)
+      await this.kernel.exec({
+        message: `echo ${response.password} | sudo -S caddy trust`,
+        path: this.kernel.homedir
+      }, (e) => {
+  //        ondata(e)
+  //      console.log(e)
+  //        if (/Caddy Local Authority/i.test(e.cleaned)) {
+  //          trusted = true
+  //        }
+      })
+    }
+  }
+  async installed() {
+    let e = await this.kernel.exists(this.kernel.path("cache/XDG_DATA_HOME/caddy/pki/authorities/local/root.crt"))
+    if (e) {
+      if (this.kernel.platform === "win32") {
+        return this.kernel.bin.installed.conda.has("caddy")
+      } else {
+        return this.kernel.bin.installed.conda.has("caddy") && this.kernel.bin.installed.conda.has("nss")
+      }
+    } else {
+      return false
+    }
+  }
+  async uninstall(req, ondata) {
+    ondata({ raw: "cleaning up\r\n" })
+    await this.kernel.bin.exec({
+      message: `conda remove ${this.cmd()}`,
+    }, ondata)
+    const folder = this.kernel.path("cache/XDG_DATA_HOME/caddy")
+    await rimraf(folder)
+    ondata({ raw: "finished cleaning up\r\n" })
+  }
+}
+module.exports = Caddy

package/kernel/bin/cloudflared.js

@@ -1,5 +1,6 @@
 const fs = require('fs')
 class Cloudflared {
+  description = "Cloudflared lets you expose your local apps to the outside world via Cloudflare Tunnel."
   async uninstall(req, ondata) {
     ondata({ raw: "cleaning up\r\n" })
     let bin = this.kernel.bin

package/kernel/bin/conda.js

@@ -4,6 +4,7 @@ const fetch = require('cross-fetch')
 const { glob } = require('glob')
 const semver = require('semver')
 class Conda {
+  description = "Pinokio uses Conda to install various useful programs in an isolated manner."
   urls = {
     darwin: {
       //x64: "https://repo.anaconda.com/miniconda/Miniconda3-py310_23.5.2-0-MacOSX-x86_64.sh",
@@ -119,6 +120,7 @@ report_errors: false`)
 //  }
   async check() {
     let res = await this.kernel.bin.exec({ message: `conda list` }, (stream) => {
+//      process.stdout.write(stream.raw)
 //        console.log("conda list check", { stream })
     })
 
@@ -176,7 +178,6 @@ report_errors: false`)
         }
       }
     }
-    console.log("> Check", { conda_check, conda })
     this.kernel.bin.installed.conda = conda
     return conda_check.conda && conda_check.mamba && conda_check.sqlite
     //return conda_check.conda && conda_check.mamba
@@ -250,11 +251,18 @@ report_errors: false`)
     // 2. The pinned file says conda-libmamba-solver=24.11.1
     // 3. so after conda update --all, it should be conda-libmamba-solver=24.11.1
 
+    let mods = this.kernel.bin.mods.filter((m) => {
+      return req.dependencies.includes(m.name)
+//      return ["zip", "uv", "node", "huggingface", "gxx", "git", "ffmpeg", "caddy"].includes(m.name)
+    }).map((m) => {
+      return m.mod.cmd()
+    }).join(" ")
+    console.log("Conda dependencies to install", { mods })
 
     let cmds = [
       //"conda clean -y --index-cache",
       "conda clean -y --all",
-      "conda install -y -c conda-forge sqlite=3.47.2",
+      `conda install -y -c conda-forge sqlite=3.47.2 ${mods}`,
 
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_connect_timeout_secs 20`,
 //      `conda config --file ${this.kernel.path('condarc')} --set remote_read_timeout_secs 300`,

package/kernel/bin/cuda.js

@@ -6,20 +6,12 @@ class Cuda {
           "conda clean -y --all",
           "conda install -y cudnn libzlib-wapi -c conda-forge",
         ]
-//        conda: {
-//          name: "base",
-//          activate: "minimal"
-//        }
       }, ondata)
       await this.kernel.bin.exec({
         message: [
           "conda clean -y --all",
           "conda install -y cuda -c nvidia/label/cuda-12.1.0",
         ]
-//        conda: {
-//          name: "base",
-//          activate: "minimal"
-//        }
       }, ondata)
     } else {
       await this.kernel.bin.exec({
@@ -27,20 +19,12 @@ class Cuda {
           "conda clean -y --all",
           "conda install -y cudnn -c conda-forge",
         ]
-//        conda: {
-//          name: "base",
-//          activate: "minimal"
-//        }
       }, ondata)
       await this.kernel.bin.exec({
         message: [
           "conda clean -y --all",
           "conda install -y cuda -c nvidia/label/cuda-12.1.0",
         ]
-//        conda: {
-//          name: "base",
-//          activate: "minimal"
-//        }
       }, ondata)
       if (this.kernel.platform === "linux") {
         await this.kernel.bin.exec({

package/kernel/bin/ffmpeg.js

@@ -3,17 +3,15 @@ const fetch = require('cross-fetch')
 const { rimraf } = require('rimraf')
 const decompress = require('decompress');
 class Ffmpeg {
+  cmd() {
+    return "ffmpeg"
+  }
   async install(req, ondata) {
     await this.kernel.bin.exec({
       message: [
         "conda clean -y --all",
-        //"conda install -y -c conda-forge ffmpeg=5.1.2",
-        "conda install -y -c conda-forge ffmpeg"
+        `conda install -y -c conda-forge ${this.cmd()}`
       ]
-//      conda: {
-//        name: "base",
-//        activate: "minimal"
-//      }
     }, ondata)
   }
   async installed() {