pterm 0.0.1 → 0.0.5

package/README.md

@@ -0,0 +1,220 @@
+# Pinokio Terminal
+
+Interact with Pinokio through terminal commands
+
+# Install
+
+```
+npm install -g pterm
+```
+
+# Usage
+
+## version
+
+prints the current version
+
+```
+pinokio version
+```
+
+## start
+
+Start a pinokio script. Arguments can be passed into the script
+
+### syntax
+
+```
+pinokio start <script_path> [<arg1>, <arg2>, ...]
+```
+
+### examples
+
+Starting a script named `install.js`:
+
+```
+pinokio start install.js
+```
+
+Starting a script named `start.js` with parameters:
+
+```
+pinokio start start.js --port=3000 --model=google/gemma-3n-E4B-it
+```
+
+Above command starts the script `start.js` with the following args:
+
+```
+{
+  port: 3000,
+  model: "google/gemma-3n-E4B-it"
+}
+```
+
+Which can be accessed in the `start.js` script, for example:
+
+```json
+{
+  "daemon": true,
+  "run": [{
+    "method": "shell.run",
+    "params": {
+      "env": {
+        "PORT": "{{args.port}}"
+      },
+      "message": "python app.py --checkpoint={{args.model}}"
+    }
+  }]
+}
+```
+
+## stop
+
+Stops a script if running:
+
+### syntax
+
+```
+pinokio stop <script_path>
+```
+
+
+### example
+
+Stop the `start.js` script if it's running:
+
+```
+pinokio stop start.js
+```
+
+## run
+
+Run a launcher. Equivalent to the user visiting a launcher page. Will run whichever script is the current default script.
+
+### syntax
+
+```
+pinokio run <launcher_path>
+```
+
+### examples
+
+Launch the launcher in the current path
+
+```
+pinokio run .
+```
+
+Launch from absolute path
+
+```
+pinokio run /pinokio/api/test
+```
+
+## filepicker
+
+Display a file picker dialog, which lets the user select one or more file or folder paths, powered by tkinter.
+
+This API is NOT for uploading the actual files but for submitting file paths.
+
+### syntax
+
+```
+pinokio filepicker [<arg>, <arg>, ...]
+```
+
+Where args can be one of the following:
+
+- `<arg>`: script flags
+  - `--title`: (optional) file dialog title.
+  - `--type`: (optional) which type to select. Either "folder" or "file". If not specified, the value is "file". 
+  - `--path`: (optional) specify path to open the file dialog from. If not specified, just use the default path.
+  - `--multiple`: (optional) whether to allow multiple path selection (`true` or `false`). Default is `false`.
+  - `--filetype`: (optional) file types to accept. you can specify multiple `--filetype` flags. The format must follow `type/extension,extension,extension,...` (Example: `--filetype='image/*.png,*.jpg`)
+
+### examples
+
+#### Select a folder path
+
+```
+pinokio filepicker --type=folder
+```
+
+#### Select a file path
+
+The most basic command lets users select a single file:
+
+```
+pinokio filepicker
+```
+
+which is equivalent to:
+
+```
+pinokio filepicker --type=file
+```
+
+#### Select multiple files
+
+```
+pinokio filepicker --multiple
+```
+
+#### Open the filepicker from the current path
+
+```
+pinokio filepicker --path=.
+```
+
+#### Open an image filepicker
+
+```
+pinokio filepicker --filetype='images/*.png,*.jpg,*.jpeg'
+```
+
+#### Open a filepicker with multiple file types
+
+```
+pinokio filepicker --filetype='images/*.png,*.jpg,*.jpeg' --filetype='docs/*.pdf'
+```
+
+
+## push
+
+Send a desktop notification
+
+### syntax
+
+```
+pinokio push <message> [<arg>, <arg>, ...]
+```
+
+- `message`: a message to send
+- `<arg>`: script flags
+  - `--title`: (optional) push notification title
+  - `--subtitle`: (optional) push notification subtitle
+  - `--image`: (optional) custom image path (can be both relative and absolute paths)
+  - `--sound`: (optional) true|false (default is false)
+  - `--wait`: (optional) wait for 5 seconds
+  - `--timeout`: (optional) wait for N seconds
+
+### examples
+
+#### send a simple notification
+
+```
+pinokio push 'hello world'
+```
+
+#### notification with sound
+
+```
+pinokio push 'this is a notification' --sound
+```
+
+#### notification with an image
+
+```
+pinokio push 'this is an image notification' --image=icon.png
+```
+

package/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+const path = require('path')
+const yargs = require('yargs/yargs')
+const { hideBin } = require('yargs/helpers')
+const Script = require('./script')
+const Util = require('./util')
+const argv = yargs(hideBin(process.argv)).parse();
+const script = new Script();
+const util = new Util();
+(async () => {
+  if (argv._.length > 0) {
+    let cmd = argv._[0].toLowerCase()
+    if (cmd === "push") {
+      let response = await util.push(argv)
+    } else if (cmd === "version") {
+      console.log("v" + require('./package.json').version)
+    } else if (cmd === "filepicker") {
+      await util.filepicker(argv)
+    } else if (cmd === "download") {
+      await util.download(argv)
+    } else if (cmd === "stop") {
+      await script.stop(argv)
+    } else if (cmd === "start") {
+      if (argv._.length > 1) {
+        let uri = argv._[1]
+        await script.start(uri, true) 
+      } else {
+        console.error("required argument: <uri>")
+      }
+    } else if (cmd === "run") {
+      if (argv._.length > 1) {
+        let _uri = argv._[1]
+        const uri = path.resolve(process.cwd(), _uri)
+        // try downloading first
+        if (path.isAbsolute(uri)) {
+        } else {
+          // url
+          await util.download(argv)
+        }
+        while(true) {
+          let default_uri = await script.default_script(uri)
+          if (default_uri) {
+            if (path.isAbsolute(default_uri)) {
+              await new Promise((resolve, reject) => {
+                script.start(default_uri, false, (packet) => {
+                  if (packet.type === "result") {
+                    resolve()
+                  }
+                })
+              })
+              if (script.killed) {
+                break
+              }
+            } else {
+              // open in browser
+              let response = await util.open_url(default_uri)  
+              console.log({ response })
+              break
+            }
+          } else {
+            break
+          }
+        }
+        if (script.killed) {
+          process.exit()
+        }
+      } else {
+        console.error("required argument: <uri>")
+      }
+    }
+  }
+})();

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "pterm",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "",
   "main": "index.js",
+  "bin": {
+    "pinokio": "./index.js"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.10.0",
+    "unws": "^0.3.0",
+    "yargs": "^17.7.2"
+  }
 }

package/rpc.js

@@ -0,0 +1,71 @@
+const { WebSocket } = require('unws')
+class RPC {
+  constructor(url) {
+    this.url = url
+  }
+  async status(rpc) {
+    let res = await new Promise((resolve, reject) => {
+      this.run({
+        status: true,
+        ...rpc
+      }, (stream) => {
+        resolve(stream.data)
+        this.ws.close()
+      })
+    })
+    return res
+  }
+  close() {
+    this.ws.close()
+  }
+  stop(rpc) {
+    this.run({
+      stop: true,
+      ...rpc
+    })
+  }
+  run (rpc, ondata) {
+    // use fetch
+    /*
+      FormData := [
+        types_array: ['number', 'boolean']
+      ]
+      body := {
+
+      }
+    */
+    return new Promise((resolve, reject) => {
+      if (this.ws) {
+        this.ws.send(JSON.stringify(rpc))
+      } else {
+        this.ws = new WebSocket(this.url)
+        this.ws.addEventListener('open', () => {
+          this.ws.send(JSON.stringify(rpc))
+        });
+        this.ws.addEventListener('message', (message) => {
+          /******************************************************************************
+
+
+          ******************************************************************************/
+          if (ondata) {
+            const packet = JSON.parse(message.data);
+            ondata(packet)
+          }
+        });
+        this.ws.addEventListener('close', () => {
+//          console.log('Disconnected from WebSocket endpoint', { error: this.error, result: this.result });
+          delete this.ws
+          resolve()
+        });
+      }
+    })
+  }
+  respond(response) {
+    if (this.ws) {
+      this.ws.send(JSON.stringify(response))
+    } else {
+      throw new Error("socket not connected")
+    }
+  }
+}
+module.exports = RPC

package/script.js

@@ -0,0 +1,163 @@
+const path = require('path')
+const RPC = require('./rpc')
+class Script {
+  listen(onKey) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    const handler = (key) => {
+      onKey(key);
+
+      // Optional: handle Ctrl+C (SIGINT)
+      if (key === '\u0003') { // Ctrl+C
+        cleanup();
+        process.exit();
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.off('data', handler);
+    };
+
+    process.stdin.on('data', handler);
+
+    return cleanup; // call this to stop listening
+  }
+  async default_script (uri) {
+    const rpc = new RPC("ws://localhost:42000")
+    const stop = () => {
+      rpc.run({
+        method: "kernel.api.stop",
+        params: { uri }
+      }, (packet) => {
+      })
+    }
+    process.on("SIGINT", () => {
+      stop()
+    });
+    process.on("SIGTERM", () => {
+      stop()
+    });
+    process.on("beforeExit", (code) => {
+      stop()
+    });
+    process.on("exit", (code) => {
+      stop()
+    });
+    let default_uri = await new Promise((resolve, reject) => {
+      rpc.run({ uri, mode: "open" }, (packet) => {
+        if (packet.data && packet.data.uri) {
+          // start
+          //rpc.stop({ uri })
+          stop()
+          resolve(packet.data.uri)
+        }
+      })
+    })
+    return default_uri
+  }
+  async stop(argv) {
+    if (argv._.length > 1) {
+      let _uri = argv._[1]
+      const uri = path.resolve(process.cwd(), _uri)
+      const rpc = new RPC("ws://localhost:42000")
+      rpc.run({
+        method: "kernel.api.stop",
+        params: { uri }
+      }, (packet) => {
+        process.exit()
+      })
+    } else {
+      console.error("required argument: <uri>")
+    }
+  }
+  async start(_uri, kill, ondata) {
+    const cols = process.stdout.columns;
+    const rows = process.stdout.rows;
+    const rpc = new RPC("ws://localhost:42000")
+
+    const uri = path.resolve(process.cwd(), _uri)
+
+    const stop = () => {
+      this.killed = true
+      rpc.run({
+        method: "kernel.api.stop",
+        params: { uri },
+      }, (packet) => {
+        rpc.stop({ uri })
+      })
+    }
+    process.on("SIGINT", () => {
+      stop()
+    });
+    process.on("SIGTERM", () => {
+      stop()
+    });
+    process.on("beforeExit", (code) => {
+      stop()
+    });
+    process.on("exit", (code) => {
+      stop()
+    });
+    this.key_stop = this.listen((key) => {
+      if (key.length >= 256) {
+        rpc.run({
+          id: this.shell_id,
+          paste: true,
+          key: key
+        })
+      } else {
+        rpc.run({
+          id: this.shell_id,
+          key: key
+        })
+      }
+    });
+    process.stdout.on('resize', () => {
+      const cols = process.stdout.columns;
+      const rows = process.stdout.rows;
+      rpc.run({
+        id: this.shell_id,
+        resize: {
+          cols,
+          rows,
+        }
+      }, (packet) => {
+      })
+    });
+    await rpc.run({
+      uri,
+      client: {
+        cols,
+        rows,
+      }
+    }, (packet) => {
+      if (packet.type === "stop") {
+        rpc.stop({ uri })
+        if (kill) {
+          this.key_stop()
+          process.exit()
+        }
+      } else if (packet.type === "disconnect") {
+        rpc.close()
+        if (kill) {
+          this.key_stop()
+          process.exit()
+        }
+      } else if (packet.type === "stream") {
+        if (packet.data.id) {
+          this.shell_id = packet.data.id
+        }
+        process.stdout.write(packet.data.raw)
+      }
+      if (ondata) {
+        ondata(packet)
+      }
+    })
+  };
+
+}
+module.exports = Script

package/util.js

@@ -0,0 +1,99 @@
+const os = require('os')
+const axios = require('axios')
+const path = require('path')
+const RPC = require('./rpc')
+class Util {
+  async filepicker(argv) {
+    const rpc = new RPC("ws://localhost:42000")
+    if (argv.path) {
+      argv.path = path.resolve(process.cwd(), argv.path)
+    }
+    await rpc.run({
+      method: "kernel.bin.filepicker",
+      params: argv
+    }, (packet) => {
+      if (packet.type === "result") {
+        rpc.close()
+        if (packet.data.paths.length > 0) {
+          for(let p of packet.data.paths) {
+            process.stdout.write(p)
+            process.stdout.write("\n")
+          }
+        }
+      } else if (packet.type === "stream") {
+//        process.stdout.write(packet.data.raw)
+      }
+    })
+  }
+  async push(argv) {
+    if (argv._ && argv._.length > 1 && !argv.message) {
+      argv.message = argv._[1]
+    }
+    if (argv.image && !path.isAbsolute(argv.image)) {
+      argv.image = path.resolve(process.cwd(), argv.image)
+    }
+    let response = await axios.post("http://localhost:42000/push", argv)
+    return response
+  }
+  async open_url(url) {
+    let response = await axios.post("http://localhost:42000/go", { url })
+    return response
+  }
+  async download(argv) {
+    if (argv._.length > 1) {
+      let uri = argv._[1]
+      const rpc = new RPC("ws://localhost:42000")
+      await rpc.run({
+        method: "kernel.bin.install2",
+        params: {}
+      }, (packet) => {
+        if (packet.type === "result") {
+          rpc.close()
+        } else if (packet.type === "stream") {
+          process.stdout.write(packet.data.raw)
+        }
+      })
+      if (!uri.endsWith(".git")) {
+        uri = uri + ".git"
+      }
+
+      let exists;
+      await rpc.run({
+        method: "kernel.bin.path_exists",
+        params: { uri }
+      }, (packet) => {
+        if (packet.type === "result") {
+          exists = packet.data
+          rpc.close()
+        }
+      })
+
+      if (!exists) {
+        let message = `git clone ${uri}`
+        let name = new URL(uri).pathname.split("/").pop()
+        if (argv._.length > 2) {
+          name = argv._[2]
+          message = `git clone ${uri} ${name}`
+        }
+        if (argv.b) {
+          let branch = argv.b
+          message += ` -b ${branch}`
+        }
+        await rpc.run({
+          method: "shell.run",
+          params: { message, path: "~/api" }
+        }, (packet) => {
+          if (packet.type === "result") {
+            rpc.close()
+          } else if (packet.type === "stream") {
+            process.stdout.write(packet.data.raw)
+          }
+        })
+      }
+      process.exit()
+    } else {
+      console.error("required argument: <uri>")
+    }
+  }
+}
+module.exports = Util