pinokiod 3.8.1530 → 3.8.1533

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]
@@ -160,7 +175,6 @@ class Api {
 
     await this.kernel.stopCloudflare({ path: requestPath })
 
-
     // if there are any pending waiters, delete them
 
     if (this.waiter[requestPath]) {
@@ -431,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)) {
@@ -572,9 +590,7 @@ 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("");
@@ -583,6 +599,10 @@ class Api {
 
     let { cwd, script } = await this.resolveScript(request.path)
 
+    if (request.cwd) {
+      cwd = request.cwd
+    }
+
     let memory = {
       script: this.kernel.script,
       input,
@@ -635,7 +655,6 @@ class Api {
         break;
       }
     }
-
     // replace {{{ }}} with {{ }}
     rpc = this.kernel.template.flatten(rpc)
 
@@ -769,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 {
@@ -987,6 +1007,7 @@ class Api {
                   uri: request.path
                 }
               })
+              console.log("<<<<<< STOPPED", request)
               return { request, input: result, step: rpc.next, total: script.run.length, args }
             }
 
@@ -1232,7 +1253,6 @@ class Api {
       } else {
         console.log({ request })
         let { cwd, script } = await this.resolveScript(request.path)
-        request.cwd = cwd
 
         if (!script) {
           this.ondata({

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/git.js

@@ -5,15 +5,26 @@ const { rimraf } = require('rimraf')
 const path = require("path")
 class Git {
   cmd() {
-    return "git git-lfs gh"
+    if (this.kernel.platform === "darwin") {
+      return "git git-lfs"
+    } else {
+      return "git git-lfs gh"
+    }
   }
   async install(req, ondata) {
-    await this.kernel.bin.exec({
-      message: [
-        "conda clean -y --all",
-        `conda install -y -c conda-forge ${this.cmd()}`
-      ]
-    }, ondata)
+    if (this.kernel.platform === "darwin") {
+      await this.kernel.bin.exec({
+        conda: { skip: true },
+        message: "brew install gh",
+      }, ondata)
+    } else {
+      await this.kernel.bin.exec({
+        message: [
+          "conda clean -y --all",
+          `conda install -y -c conda-forge ${this.cmd()}`
+        ]
+      }, ondata)
+    }
     await fs.promises.mkdir(this.kernel.path("config/gh"), { recursive: true }).catch((e) => { })
 //    if (this.kernel.platform === 'win32') {
 //      let gitconfig_path = path.resolve(this.kernel.homedir, "gitconfig")
@@ -29,11 +40,26 @@ class Git {
 //    }
   }
   async installed() {
-    let gh_config_exists = await this.kernel.exists("config/gh")
-    return this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git") && this.kernel.bin.installed.conda.has("gh") && gh_config_exists
+    if (this.kernel.platform === "darwin") {
+      let gh_config_exists = await this.kernel.exists("config/gh")
+      console.log("conda installed", this.kernel.bin.installed.conda)
+      return this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git") && this.kernel.bin.installed.brew.has("gh") && gh_config_exists
+    } else {
+      let gh_config_exists = await this.kernel.exists("config/gh")
+      console.log("conda installed", this.kernel.bin.installed.conda)
+      return this.kernel.bin.installed.conda && this.kernel.bin.installed.conda.has("git") && this.kernel.bin.installed.conda.has("gh") && gh_config_exists
+    }
   }
   async uninstall(req, ondata) {
-    await this.kernel.bin.exec({ message: "conda remove git gh" }, ondata)
+    if (this.kernel.platform === "darwin") {
+      await this.kernel.bin.exec({ message: "conda remove git" }, ondata)
+      await this.kernel.bin.exec({
+        conda: { skip: true },
+        message: "brew uninstall gh",
+      })
+    } else {
+      await this.kernel.bin.exec({ message: "conda remove git gh" }, ondata)
+    }
   }
   env() {
     let gitconfig_path = path.resolve(this.kernel.homedir, "gitconfig")

package/kernel/bin/index.js

@@ -56,7 +56,6 @@ class Bin {
       params.cols = this.client.cols
       params.rows = this.client.rows
     }
-    console.log({ params })
     let response = await this.kernel.shell.run(params, null, ondata)
     return response
   }
@@ -360,17 +359,12 @@ class Bin {
             conda_versions[name] = version
             if (name === "conda") {
               conda_check.conda = true
-//              //if (String(version) === "24.11.1") {
-//              if (String(version) === "24.11.3") {
-//                conda_check.conda = true
-//              }
             }
             if (name === "conda-libmamba-solver") {
               //if (String(version) === "24.7.0") {
               let channel = chunks[3]
               let coerced = semver.coerce(version)
               let mamba_requirement = ">=24.11.1"
-//              console.log({ name, channel, version })
               //if (semver.satisfies(coerced, mamba_requirement) && channel === "conda-forge") {
               if (semver.satisfies(coerced, mamba_requirement)) {
                 conda_check.mamba = true
@@ -382,16 +376,6 @@ class Bin {
               if (String(version) === "3.47.2") {
                 conda_check.sqlite = true
               }
-//              let coerced = semver.coerce(version)
-//              let sqlite_requirement = ">=3.47.2"
-//  //            console.log({ coerced, version, sqlite_requirement })
-//              if (semver.satisfies(coerced, sqlite_requirement)) {
-//                console.log("semver satisfied")
-//
-//                conda_check.sqlite = true
-//              } else {
-//                console.log("semver NOT satisfied")
-//              }
             }
           }
         } else {
@@ -443,15 +427,12 @@ class Bin {
 
       let brew_path = path.resolve(this.kernel.homedir, "bin", "homebrew")
       let brew_exists = await this.exists(brew_path)
-//      console.log({ brew_path, brew_exists })
 
       let brew = []
       if (brew_exists) {
         start = false
         res = await this.exec({ message: `brew list -1`, conda: { skip: true } }, (stream) => {
-//          console.log("brew list check", { stream })
         })
-//        console.log("BREW", res.response)
         lines = res.response.split(/[\r\n]+/).slice(0, -1)  // ignore last line since it's the prompt
         let end = false
         for(let line of lines) {
@@ -475,7 +456,6 @@ class Bin {
 
 
       // check brew_installed
-//      console.log("checking brew installed")
       let e = await this.kernel.bin.exists("homebrew")
       let { stdout }= await this.exec({ message: "xcode-select -p", conda: { skip: true } }, (stream) => { })
       let e2 = /(.*Library.*Developer.*CommandLineTools.*|.*Xcode.*Developer.*)/gi.test(stdout)
@@ -736,7 +716,6 @@ class Bin {
     //  }
     //}
     if (this.kernel.shell) {
-      console.log(">>> shell reset")
       this.kernel.shell.reset()
     }
     await this.init()
@@ -975,6 +954,8 @@ class Bin {
           let dependencies
           if (r.name === "conda") {
             dependencies = config.bin.conda_requirements
+            console.log("check dependencies", dependencies)
+            requirements[i].dependencies = dependencies
           }
           let installed = await this.check_installed(r, dependencies)
           requirements[i].installed = installed

package/kernel/bin/setup.js

@@ -126,5 +126,21 @@ module.exports = {
         "caddy"
       ]
     }
+  },
+  connect: (kernel) => {
+    return {
+      icon: "fa-solid fa-wifi",
+      title: "API Connect",
+      description: "Connect with 3rd party APIs",
+      requirements: [
+        { name: "conda", },
+        { name: "git", },
+        { name: "caddy", },
+      ],
+      conda_requirements: [
+        "git",
+        "caddy"
+      ]
+    }
   }
 }

package/kernel/connect/index.js

@@ -0,0 +1,25 @@
+const fetch = require('cross-fetch')
+const X = require('./providers/x')
+class Connect {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.x = new X(kernel)
+  }
+  async request(provider, method, req) {
+    let res = await this[provider].request(method, req)
+    return res
+  }
+  async login(provider, req) {
+    let res = await this[provider].login(req)
+    return res
+  }
+  async logout(provider, req) {
+    let res = await this[provider].logout(req)
+    return res
+  }
+  async keys(provider) {
+    let res = await this[provider].keys()
+    return res
+  }
+}
+module.exports = Connect

package/kernel/connect/providers/github/README.md

@@ -0,0 +1,11 @@
+---
+
+# Usage
+
+When you log into Github here, the login will be used for the git installed within Pinokio.
+
+Logging into Github lets you do things like:
+
+1. Cloning from Private Repositories
+2. Publishing to Github
+3. Use all `gh` CLI commands in all Pinokio shells ([Learn more](https://cli.github.com/))

package/kernel/connect/providers/x/README.md

@@ -0,0 +1,96 @@
+---
+
+# Usage
+
+## 1. Iniitialize
+
+First include the script
+
+```html
+<script src="https://pinokio.localhost/x.js"></script>
+```
+
+Then initialize the X object
+
+```javascript
+const x = new X()
+```
+
+## 2. Make API Calls
+
+Now you can make API calls to X v2 API (Without worrying about authentication). For example:
+
+```javascript
+await x.tweet({ text: text })
+```
+
+The instantiated object `x` is equivalent to the `client.v2` object from [node-twitter-api-v2](https://github.com/PLhery/node-twitter-api-v2)
+
+Read the full API documentation here: https://github.com/PLhery/node-twitter-api-v2/blob/master/doc/v2.md
+
+---
+
+# Examples
+
+## 1. Minimal Post App
+
+The authentication is automatically taken care of. You just need to make a POST request to the `/connect/x/api` endpoint, using ANY x.com API.
+
+```html
+<html>
+  <body>
+    <form>
+      <input type='text' id='post'/>
+      <input type='submit'>
+    </form>
+    <script src="https://pinokio.localhost/x.js"></script>
+    <script>
+      const x = new X()
+      document.querySelector("form").addEventListener('submit', async (e) => {
+        e.preventDefault()
+        let text = document.querySelector("#post").value
+        await x.tweet({ text: text })
+      })
+    </script>
+  </body>
+</html>
+```
+
+---
+
+## 2. Upload Media App
+
+```html
+<html>
+  <body>
+    <form>
+      <input type='file' id='media' name='media'>
+      <input type='submit'>
+    </form>
+    <script src="https://pinokio.localhost/x.js"></script>
+    <script>
+      const x = new X()
+      document.querySelector("form").addEventListener('submit', async (e) => {
+        e.preventDefault()
+        // 1. get the uploaded file
+        let media = document.querySelector("#media").files[0]
+        // 2. determine the media_type ("tweet_gif", "tweet_image", or "tweet_video")
+        let type = media.type; // e.g., "image/png", "video/mp4", "image/gif"
+        let media_category
+        if (type.startsWith("image/")) {
+          media_category = (type === "image/gif" ? "tweet_gif" : "tweet_image");
+        } else if (type.startsWith("video/")) {
+          media_category = "tweet_video"
+        }
+        // 3. upload media
+        let media_id = await x.uploadMedia(media, { media_category })
+        // 4. post the uploaded media
+        let res = await x.tweet({ media: { media_ids: [media_id] }})
+        console.log(res)
+      })
+    </script>
+  </body>
+</html>
+```
+
+---

package/kernel/connect/providers/x/index.js

@@ -0,0 +1,152 @@
+const fs = require('fs')
+const path = require('path')
+const fetch = require('cross-fetch')
+const FormData = require('form-data');
+const marked = require('marked')
+const { TwitterApi } = require('twitter-api-v2')
+class X {
+  id = 'd2FQZ0U4NXpzYnRyS1hZeHBvbUc6MTpjaQ'
+  constructor(kernel) {
+    this.kernel = kernel
+  }
+  async readme() {
+    let md = await fs.promises.readFile(path.resolve(__dirname, "README.md"), "utf8")
+    return marked.parse(md, {
+      //baseUrl: req._parsedUrl.pathname.replace(/^\/_api/, "/raw/") + "/"
+      //baseUrl: req.originalUrl + "/"
+    })
+  }
+  async persist(auth) {
+    this.auth = auth
+    this.auth.expires_at = Date.now() + this.auth.expires_in * 1000
+    let authPath = this.kernel.path('connect/x.json')
+    await fs.promises.mkdir(this.kernel.path("connect"), { recursive: true }).catch((e) => { })
+    await fs.promises.writeFile(authPath, JSON.stringify(this.auth, null, 2))
+  }
+  async destroy() {
+    await fs.promises.rm(this.kernel.path("connect/x.json"))
+    this.auth = null
+  }
+  async sync() {
+    // check if auth exists
+    //  if not, throw error
+    let authPath = this.kernel.path('connect/x.json')
+    this.auth = (await this.kernel.loader.load(authPath)).resolved
+    if (!this.auth) {
+      throw new Error("not authenticated")
+      return
+    }
+    if (!this.auth.refresh_token) {
+      throw new Error("no refresh token")
+      return
+    }
+
+    // check if auth has expired
+    //  if expired, refresh and return
+    if (Date.now() < this.auth.expires_at) {
+      console.log("authentication valid")
+      return
+    }
+
+
+    console.log("auth expired. refresh....", JSON.stringify({ auth: this.auth, id: this.id }, null, 2))
+    // expired — refresh
+    const response = await fetch('https://api.twitter.com/2/oauth2/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: this.auth.refresh_token,
+        client_id: this.id
+      })
+    }).then((res) => {
+      return res.json()
+    });
+    await this.persist(response)
+    return this.auth
+  }
+  async keys() {
+    await this.sync()
+    return this.auth
+  }
+  async request(method, req) {
+    /*
+      method := "uploadMedia"
+      params := {
+        "value.0", val1,
+        "type.0": "String",
+        "value.1": val2,
+        "type.1": "Blob"
+      }
+
+      uploadMedia(
+        val1,
+        {
+          key2: val2,
+          key3: val3
+        }
+      )
+    */
+    await this.sync()
+    const contentType = req.headers['content-type'];
+    let args
+    if (contentType.toLowerCase() === "application/json") {
+      // don't transform
+      args = req.body
+      let response = await this.client.v2[method](...args)
+      return response
+    } else {
+      args = []
+      let body = Object.assign({}, req.body)
+      if (req.files) {
+        for (const file of req.files) {
+          body[file.fieldname] = file.buffer
+        }
+      }
+      let types = []
+      for(let key in body) {
+        let chunks = key.split(".")
+        let index = parseInt(chunks[1])
+        if (chunks[0] === "type") {
+          types[index] = body[key]
+        }
+      }
+      for(let key in body) {
+        let chunks = key.split(".")
+        let index = parseInt(chunks[1])
+        if (chunks[0] === "value") {
+          let type = types[index]
+          if (type === "Object") {
+            args[index] = JSON.parse(body[key])
+          } else {
+            args[index] = body[key]
+          }
+        }
+      }
+      console.log({ args, method })
+
+      this.client = new TwitterApi(this.auth.access_token);
+      let response = await this.client.v2[method](...args)
+      return response
+    }
+  }
+  async login (req) {
+    const authHeader = 'Basic ' + Buffer.from(`${this.id}:`).toString('base64');
+    const response = await fetch('https://api.x.com/2/oauth2/token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+//        'Authorization': authHeader
+      },
+      body: JSON.stringify(req.payload)
+    }).then((res) => {
+      return res.json()
+    });
+    await this.persist(response)
+    return this.auth
+  }
+  async logout (req) {
+    await this.destroy() 
+  }
+}
+module.exports = X

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 Connect = require('./connect')
 //const kill = require('./tree-kill');
 const kill = require('kill-sync')
 const VARS = {
@@ -45,10 +46,6 @@ const VARS = {
 
 //const memwatch = require('@airbnb/node-memwatch');
 class Kernel {
-  //schema = ">=1.0.0"
-  //schema = "<=2.1.0"
-  //schema = "<=3.2.0"
-  //schema = "<=3.7.0"
   schema = "<=4.0.0"
   constructor(store) {
     this.fetch = fetch
@@ -81,13 +78,6 @@ 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.peer = new Peer()
     this.shellpath = shellPath.sync()
 
 
@@ -292,41 +282,7 @@ class Kernel {
 
       // 9. announce self to the peer network
       this.peer.announce()
-      
     }
-
-    //if (https_installed && peer_active) {
-
-    //  // 1. get the process list
-    //  await this.processes.refresh()
-
-    //  // 2. refresh peer info to reflect the proc info
-    //  await this.peer.refresh()
-
-    //  // 3. load custom routers from ~/pinokio/network
-    //  await this.router.init()
-
-    //  // 4. set current local host router info
-    //  await this.router.local()
-
-    //  // 5. refresh peer info to reflect the updated router info
-    //  await this.peer.refresh()
-
-    //  // 6. tell peers to refresh
-    //  if (notify_peers) {
-    //    await this.peer.notify_peers()
-    //  }
-
-    //  // 7. update remote router
-    //  await this.router.remote()
-
-    //  // 8. update caddy config
-    //  await this.router.update()
-
-    //  // 9. announce self to the peer network
-    //  this.peer.announce()
-
-    //}
   }
   async clearLog(group) {
     let relativePath = path.relative(this.homedir, group)
@@ -599,6 +555,7 @@ class Kernel {
     this.python = new Python(this)
     this.shell = new Shells(this)
     this.router = new Router(this)
+    this.connect = new Connect(this)
     this.system = system
     this.keys = {}
     this.memory = {

package/kernel/prototype.js

@@ -30,7 +30,7 @@ class Proto {
       let proto = path.dirname(prototype_path)
       let pinokiojs = path.resolve(prototype_dir, prototype_path)
       let config = await this.kernel.require(pinokiojs)
-      if (config && config.create && typeof config.create === "function") {
+      if (config && config.run) {
         if (config.icon) {
           config.icon = "/prototype/" + proto + "/" + config.icon
         } else {

package/kernel/router/index.js

@@ -221,5 +221,15 @@ class Router {
       }
     }
   }
+  async check() {
+    try {
+      let res = await axios.get(`http://localhost:2019/config/`, {
+        timeout: 2000
+      })
+      return res.data
+    } catch (e) {
+      return null
+    }
+  }
 }
 module.exports = Router