pterm 0.0.16 → 0.0.18

package/README.md

@@ -163,6 +163,28 @@ pterm search --q="text generation"
 pterm search "tts speech synthesis" --mode=balanced --min-match=2 --limit=8
 ```
 
+## which
+
+Resolve the executable path for a command name through Pinokio's environment.
+
+### syntax
+
+```
+pterm which <command> [--json]
+```
+
+- `--json`: (optional) print the raw JSON response instead of only the path.
+
+### examples
+
+```
+pterm which node
+```
+
+```
+pterm which git --json
+```
+
 ## status
 
 Get app status by app id.
@@ -186,6 +208,59 @@ pterm status comfyanonymous-comfyui
 pterm status comfyanonymous-comfyui --probe --timeout=5000
 ```
 
+## stars
+
+List starred apps.
+
+### syntax
+
+```
+pterm stars [query words...]
+pterm stars --q="<query>"
+```
+
+### examples
+
+```
+pterm stars
+```
+
+```
+pterm stars tts
+```
+
+## star
+
+Star an app so it is preferred on Pinokio home/search ranking.
+
+### syntax
+
+```
+pterm star <app_id>
+```
+
+### example
+
+```
+pterm star comfyanonymous-comfyui
+```
+
+## unstar
+
+Remove star from an app.
+
+### syntax
+
+```
+pterm unstar <app_id>
+```
+
+### example
+
+```
+pterm unstar comfyanonymous-comfyui
+```
+
 ## logs
 
 Get app logs by app id.

package/index.js

@@ -56,6 +56,14 @@ const isHttpUri = (value) => typeof value === "string" && /^https?:\/\//i.test(v
       await util.download(argv)
     } else if (cmd === "search") {
       await util.search(argv)
+    } else if (cmd === "stars") {
+      await util.stars(argv)
+    } else if (cmd === "star") {
+      await util.setStar(argv, true)
+    } else if (cmd === "unstar") {
+      await util.setStar(argv, false)
+    } else if (cmd === "which") {
+      await util.which(argv)
     } else if (cmd === "status") {
       await util.status(argv)
     } else if (cmd === "logs") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pterm",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "",
   "main": "index.js",
   "bin": {

package/rpc.js

@@ -2,6 +2,11 @@ const { WebSocket } = require('unws')
 class RPC {
   constructor(url) {
     this.url = url
+    this.wsOptions = {
+      headers: {
+        "x-pinokio-client": "pterm"
+      }
+    }
   }
   async status(rpc) {
     let res = await new Promise((resolve, reject) => {
@@ -38,7 +43,7 @@ class RPC {
       if (this.ws) {
         this.ws.send(JSON.stringify(rpc))
       } else {
-        this.ws = new WebSocket(this.url)
+        this.ws = new WebSocket(this.url, this.wsOptions)
         this.ws.addEventListener('open', () => {
           this.ws.send(JSON.stringify(rpc))
         });

package/script.js

@@ -52,7 +52,14 @@ class Script {
       stop()
     });
     let default_uri = await new Promise((resolve, reject) => {
-      rpc.run({ uri, mode: "open" }, (packet) => {
+      rpc.run({
+        uri,
+        mode: "open",
+        source: "pterm",
+        client: {
+          source: "pterm"
+        }
+      }, (packet) => {
         if (packet.data && packet.data.uri) {
           // start
           //rpc.stop({ uri })
@@ -134,9 +141,11 @@ class Script {
     });
     await rpc.run({
       uri,
+      source: "pterm",
       client: {
         cols,
         rows,
+        source: "pterm"
       }
     }, (packet) => {
       if (packet.type === "stop") {

package/util.js

@@ -71,6 +71,92 @@ class Util {
     const response = await axios.get(url)
     this.printJson(response.data)
   }
+  async stars(argv) {
+    const query = (argv._.slice(1).join(" ") || argv.q || "").trim().toLowerCase()
+    const [preferenceResponse, appResponse] = await Promise.all([
+      axios.get("http://localhost:42000/apps/preferences"),
+      axios.get("http://localhost:42000/info/apps")
+    ])
+    const preferenceItems = preferenceResponse && preferenceResponse.data && preferenceResponse.data.items
+      ? preferenceResponse.data.items
+      : {}
+    const apps = appResponse && appResponse.data && Array.isArray(appResponse.data.apps)
+      ? appResponse.data.apps
+      : []
+    const appsById = new Map()
+    for (const app of apps) {
+      if (!app || !app.name) continue
+      appsById.set(app.name, app)
+    }
+    const starredApps = Object.entries(preferenceItems)
+      .filter(([, preference]) => preference && preference.starred)
+      .map(([appId, preference]) => {
+        const app = appsById.get(appId) || {}
+        return {
+          app_id: appId,
+          title: app.title || appId,
+          description: app.description || "",
+          icon: app.icon || "/pinokio-black.png",
+          ...preference
+        }
+      })
+      .sort((a, b) => {
+        const aLast = typeof a.last_launch_at === "string" ? Date.parse(a.last_launch_at) || 0 : 0
+        const bLast = typeof b.last_launch_at === "string" ? Date.parse(b.last_launch_at) || 0 : 0
+        if (aLast !== bLast) {
+          return bLast - aLast
+        }
+        return String(a.title || a.app_id).localeCompare(String(b.title || b.app_id))
+      })
+      .filter((app) => {
+        if (!query) return true
+        const haystack = `${app.app_id || ""}\n${app.title || ""}\n${app.description || ""}`.toLowerCase()
+        return haystack.includes(query)
+      })
+    this.printJson({
+      q: query,
+      count: starredApps.length,
+      apps: starredApps
+    })
+  }
+  async setStar(argv, starred) {
+    if (argv._.length <= 1) {
+      console.error("required argument: <app_id>")
+      return
+    }
+    const appId = argv._[1]
+    const response = await axios.put(`http://localhost:42000/apps/preferences/${encodeURIComponent(appId)}`, {
+      starred: Boolean(starred)
+    })
+    this.printJson(response.data)
+  }
+  async which(argv) {
+    if (argv._.length <= 1) {
+      console.error("required argument: <command>")
+      return
+    }
+    const command = String(argv._[1]).trim()
+    if (!command) {
+      console.error("required argument: <command>")
+      return
+    }
+    try {
+      const response = await axios.get(`http://localhost:42000/pinokio/path/${encodeURIComponent(command)}`)
+      if (argv.json) {
+        this.printJson(response.data)
+      } else if (response.data && response.data.path) {
+        process.stdout.write(String(response.data.path))
+        process.stdout.write("\n")
+      }
+    } catch (error) {
+      if (error && error.response && error.response.status === 404) {
+        console.error(`command not found: ${command}`)
+        process.exitCode = 1
+        return
+      }
+      throw error
+    }
+  }
   async filepicker(argv) {
     const rpc = new RPC("ws://localhost:42000")
     if (argv.path) {