pterm 0.0.18 → 0.0.20

package/README.md

@@ -103,15 +103,16 @@ pterm stop start.js
 
 ## run
 
-Run a launcher. Equivalent to the user visiting a launcher page. Will run whichever script is the current default script.
+Run a launcher. Equivalent to the user visiting a launcher page. By default it will run whichever script is the current launcher default. If the launcher exposes no explicit default, you can provide repeated `--default` selectors and Pinokio will match the first selector that exists in the launcher's current menu state.
 
 ### syntax
 
 ```
-pterm run <launcher_path_or_uri> [--open]
+pterm run <launcher_path_or_uri> [--default <selector>]... [--open]
 ```
 
 - `--open`: (optional) open URL results in the browser. Default behavior is to print the URL to stdout without opening a browser.
+- `--default`: (optional, repeatable) ordered launcher action selector. Each selector is matched against the current launcher menu. Selectors use launcher `href` syntax such as `run.js`, `install.js`, or `run.js?mode=Default`.
 
 ### examples
 
@@ -133,6 +134,21 @@ Run from a launcher URI and auto-open the resulting URL in browser
 pterm run https://github.com/example/my-launcher --open
 ```
 
+Run a launcher with ordered fallback selectors when the launcher has no explicit default item
+
+```
+pterm run ~/pinokio/api/facefusion-pinokio.git \
+  --default 'run.js?mode=Default' \
+  --default run.js \
+  --default install.js
+```
+
+Launch a script directly with query parameters. Query parameters are passed through as script input automatically.
+
+```
+pterm start 'run.js?mode=Default'
+```
+
 ## search
 
 Search installed or available apps.

package/index.js

@@ -2,7 +2,12 @@
 const path = require('path')
 const yargs = require('yargs/yargs')
 const { hideBin } = require('yargs/helpers')
-const argv = yargs(hideBin(process.argv)).parse();
+const argv = yargs(hideBin(process.argv))
+  .option('default', {
+    type: 'string',
+    array: true
+  })
+  .parse();
 const Script = require('./script')
 const Util = require('./util')
 const script = new Script();
@@ -89,11 +94,11 @@ const isHttpUri = (value) => typeof value === "string" && /^https?:\/\//i.test(v
           })
         }
         while(true) {
-          let default_uri = await script.default_script(uri)
-          if (default_uri) {
-            if (path.isAbsolute(default_uri)) {
+          let default_target = await script.default_script(uri, argv.default)
+          if (default_target) {
+            if (path.isAbsolute(default_target.uri)) {
               await new Promise((resolve, reject) => {
-                script.start(default_uri, false, (packet) => {
+                script.start(default_target, false, (packet) => {
                   if (packet.type === "result") {
                     resolve()
                   }
@@ -105,10 +110,10 @@ const isHttpUri = (value) => typeof value === "string" && /^https?:\/\//i.test(v
             } else {
               // default behavior is no browser side effect.
               if (argv.open) {
-                let response = await util.open_url(default_uri)
+                let response = await util.open_url(default_target.uri)
                 console.log({ response })
               } else {
-                console.log(default_uri)
+                console.log(default_target.uri)
               }
               break
             }

package/package.json

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

package/script.js

@@ -30,7 +30,44 @@ class Script {
 
     return cleanup; // call this to stop listening
   }
-  async default_script (uri) {
+  normalizeTarget(target) {
+    const appendInputValue = (input, key, value) => {
+      if (Object.prototype.hasOwnProperty.call(input, key)) {
+        if (Array.isArray(input[key])) {
+          input[key].push(value)
+        } else {
+          input[key] = [input[key], value]
+        }
+      } else {
+        input[key] = value
+      }
+    }
+    if (target && typeof target === "object" && typeof target.uri === "string") {
+      return {
+        uri: target.uri,
+        input: target.input && typeof target.input === "object" ? target.input : undefined
+      }
+    }
+    let uri = target
+    let input
+    if (!/^https?:\/\//i.test(uri)) {
+      let queryIndex = uri.indexOf("?")
+      if (queryIndex >= 0) {
+        input = {}
+        let params = new URLSearchParams(uri.slice(queryIndex + 1))
+        for (let [key, value] of params.entries()) {
+          appendInputValue(input, key, value)
+        }
+        uri = uri.slice(0, queryIndex)
+      }
+      uri = path.resolve(process.cwd(), uri)
+    }
+    return {
+      uri,
+      input
+    }
+  }
+  async default_script (uri, defaultSelectors) {
     const rpc = new RPC("ws://localhost:42000")
     const stop = () => {
       rpc.run({
@@ -51,10 +88,11 @@ class Script {
     process.on("exit", (code) => {
       stop()
     });
-    let default_uri = await new Promise((resolve, reject) => {
+    let default_target = await new Promise((resolve, reject) => {
       rpc.run({
         uri,
         mode: "open",
+        default: Array.isArray(defaultSelectors) ? defaultSelectors : undefined,
         source: "pterm",
         client: {
           source: "pterm"
@@ -64,16 +102,19 @@ class Script {
           // start
           //rpc.stop({ uri })
           stop()
-          resolve(packet.data.uri)
+          resolve({
+            uri: packet.data.uri,
+            input: packet.data.input
+          })
         }
       })
     })
-    return default_uri
+    return default_target
   }
   async stop(argv) {
     if (argv._.length > 1) {
       let _uri = argv._[1]
-      const uri = path.resolve(process.cwd(), _uri)
+      const { uri } = this.normalizeTarget(_uri)
       const rpc = new RPC("ws://localhost:42000")
       rpc.run({
         method: "kernel.api.stop",
@@ -90,7 +131,8 @@ class Script {
     const rows = process.stdout.rows;
     const rpc = new RPC("ws://localhost:42000")
 
-    const uri = path.resolve(process.cwd(), _uri)
+    const target = this.normalizeTarget(_uri)
+    const uri = target.uri
 
     const stop = () => {
       this.killed = true
@@ -139,7 +181,7 @@ class Script {
       }, (packet) => {
       })
     });
-    await rpc.run({
+    let payload = {
       uri,
       source: "pterm",
       client: {
@@ -147,7 +189,11 @@ class Script {
         rows,
         source: "pterm"
       }
-    }, (packet) => {
+    }
+    if (target.input && Object.keys(target.input).length > 0) {
+      payload.input = target.input
+    }
+    await rpc.run(payload, (packet) => {
       if (packet.type === "stop") {
         rpc.stop({ uri })
         if (kill) {