pinokiod 3.9.0 → 3.9.3

package/kernel/bin/setup.js

@@ -0,0 +1,146 @@
+const os = require('os')
+let platform = os.platform()
+module.exports = {
+  ai: (kernel) => {
+    let conda_requirements = [
+      "uv",
+      "node",
+      "huggingface",
+      "git",
+      "ffmpeg",
+//      "caddy"
+    ]
+    let requirements = [
+      { name: "conda", },
+      { name: "git", },
+  //      { name: "zip", },
+      { name: "node", },
+      { name: "ffmpeg", },
+//      { name: "caddy", }
+    ]
+    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" })
+      conda_requirements.push("gxx")
+    }
+    if (kernel.gpu === "nvidia") {
+      requirements.push({ name: "cuda", })
+      conda_requirements.push("cuda")
+    }
+    requirements = requirements.concat([
+      { name: "cloudflared" },
+//      { name: "playwright" },
+      { name: "huggingface" },
+      { name: "uv" },
+      { name: "py" },
+    ])
+    return {
+      icon: "fa-solid fa-brain",
+      title: "AI",
+      description: "Install common modules required for running AI locally",
+      requirements,
+      conda_requirements
+    }
+  },
+  javascript: (kernel) => {
+    return {
+      icon: "fa-brands fa-js",
+      title: "Node.js",
+      description: "Set up self-contained node.js development environment",
+      requirements: [
+        { name: "conda", },
+        { name: "git", },
+        { name: "node", },
+      ],
+      conda_requirements: [
+        "node",
+        "git",
+      ]
+    }
+  },
+  python: (kernel) => {
+    return {
+      icon: "fa-brands fa-python",
+      title: "Python",
+      description: "Set up self-contained python development environment",
+      requirements: [
+        { name: "conda", },
+        { name: "git", },
+        { name: "uv", },
+      ],
+      conda_requirements: [
+        "uv",
+        "git",
+      ]
+    }
+  },
+  dev: (kernel) => {
+    let requirements = [
+      { name: "conda", },
+      { name: "git", },
+      { name: "node", },
+      { name: "uv", },
+    ]
+    let conda_requirements = [
+      "uv",
+      "node",
+      "git",
+    ]
+    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" })
+      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)",
+      requirements,
+      conda_requirements,
+    }
+  },
+  network: (kernel) => {
+    return {
+      icon: "fa-solid fa-wifi",
+      title: "Network",
+      description: "Automatic HTTPS and local network sharing for ALL local apps",
+      requirements: [
+        { name: "conda", },
+        { name: "git", },
+        { name: "caddy", },
+      ],
+      conda_requirements: [
+        "git",
+        "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/bin/uv.js

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

package/kernel/bin/zip.js

@@ -1,20 +1,19 @@
 class Zip {
-  async install(req, ondata) {
+  cmd() {
     let cmd
     if (this.kernel.platform === 'win32') {
-      cmd = "conda install -y -c conda-forge 7zip"
+      cmd = "7zip"
     } else {
-      cmd = "conda install -y -c conda-forge p7zip"
+      cmd = "p7zip"
     }
+    return cmd
+  }
+  async install(req, ondata) {
     await this.kernel.bin.exec({
       message: [
         "conda clean -y --all",
-        cmd
+        `conda install -y -c conda-forge ${this.cmd()}`
       ]
-//      conda: {
-//        name: "base",
-//        activate: "minimal"
-//      }
     }, ondata)
   }
   async installed() {

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

@@ -439,4 +439,53 @@ const get_raw = async (homedir) => {
   }
   return current_env
 }
-module.exports = { ENV, get, get2, init_folders }
+
+const requirements = async (script, filepath, kernel) => {
+  let pre_items = []
+  let requires_instantiation = false
+  if (script && script.pre) {
+    let env = await get2(filepath, kernel)
+    for(let item of script.pre) {
+      if (item.env) {
+        // if index is not set, use 0 as default (for key)
+        if (!item.index) {
+          item.index = 0
+        }
+        if (item.key) {
+          const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(item.key);
+          const url = new URL(hasProtocol ? item.key : `https://${item.key}`);
+          item.host = url.host
+          item.val = await kernel.kv.get(item.host, item.index)
+        } else {
+          item.host = ""
+        }
+
+        if (env[item.env]) {
+          item.val = env[item.env]
+        } else {
+          if (item.default) {
+            if (typeof item.default === 'object') {
+              if (item.default.key) {
+                const hasProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(item.default.key);
+                const url = new URL(hasProtocol ? item.default.key : `https://${item.default.key}`);
+                item.host = url.host
+
+                let index = item.default.index || 0
+                item.index = index
+                item.val = await kernel.kv.get(item.host, index)
+              } else {
+                item.host = ""
+              }
+            } else {
+              item.val = item.default
+            }
+          }
+          requires_instantiation = true
+        }
+        pre_items.push(item)
+      }
+    }
+  }
+  return { items: pre_items, requires_instantiation }
+}
+module.exports = { ENV, get, get2, init_folders, requirements }