@zenalexa/unicli 0.207.1 → 0.208.0

package/src/adapters/cua/bench-run.yaml

@@ -0,0 +1,32 @@
+# trycua/cua bench/run — run a single computer-use benchmark.
+site: cua
+name: bench/run
+description: Run a trycua/cua computer-use benchmark
+type: bridge
+strategy: public
+binary: cua
+detect: which cua
+
+args:
+  benchmark:
+    type: str
+    required: true
+    positional: true
+    description: Benchmark name from `cua bench/list`
+  agent:
+    type: str
+    required: false
+    description: Agent backend (e.g. unicli, browser-use, claude)
+
+pipeline:
+  - exec:
+      command: cua
+      args:
+        - bench
+        - run
+        - ${{ args.benchmark }}
+        - --json
+      parse: json
+      timeout: 600000
+
+columns: [task, score, duration, agent]

package/src/adapters/godot/project-run.yaml

@@ -0,0 +1,31 @@
+# Godot project/run — run a project headlessly with optional script.
+site: godot
+name: project/run
+description: Run a Godot project in headless mode
+type: desktop
+strategy: public
+binary: godot
+detect: which godot
+
+args:
+  project:
+    type: str
+    required: true
+    positional: true
+    description: Path to project directory or project.godot file
+  script:
+    type: str
+    required: false
+    description: Optional GDScript file to run as main scene
+
+pipeline:
+  - exec:
+      command: godot
+      args:
+        - --headless
+        - --path
+        - ${{ args.project }}
+      parse: text
+      timeout: 60000
+
+columns: [output]

package/src/adapters/godot/scene-export.yaml

@@ -0,0 +1,39 @@
+# Godot scene/export — export a scene to a known format via godot --headless.
+# Closes the v0.208 coverage gap with CLI-Anything's Godot harness.
+site: godot
+name: scene/export
+description: Export a Godot scene to PNG / GLTF / DAE via headless mode
+type: desktop
+strategy: public
+binary: godot
+detect: which godot
+
+args:
+  project:
+    type: str
+    required: true
+    positional: true
+    description: Path to project directory or project.godot file
+  scene:
+    type: str
+    required: true
+    description: Scene path within the project (e.g. res://Main.tscn)
+  output:
+    type: str
+    required: true
+    description: Output file path
+
+pipeline:
+  - exec:
+      command: godot
+      args:
+        - --headless
+        - --path
+        - ${{ args.project }}
+        - --export-pack
+        - ${{ args.scene }}
+        - ${{ args.output }}
+      parse: text
+      timeout: 120000
+
+columns: [output]

package/src/adapters/hermes/sessions-search.yaml

@@ -0,0 +1,61 @@
+# NousResearch/hermes-agent sessions/search — query Hermes session FTS.
+# Hermes stores session history in a SQLite database at ~/.hermes/sessions.db.
+#
+# Security:
+#   - `args.query` is passed via env var UNICLI_QUERY (bash literal, no shell injection)
+#   - Single quotes in the query are doubled (`'` → `''`) via bash parameter
+#     expansion before being injected into the SQL string literal — this is
+#     the standard SQL string-literal escape. FTS5 MATCH still interprets its
+#     own query grammar (e.g. `OR`, `*`) as FTS operators, which is
+#     intentional for search.
+#   - `args.limit` is typed int in adapter args; bash strips non-digits as
+#     a belt-and-suspenders guard to keep LIMIT clause integer-only.
+site: hermes
+name: sessions/search
+description: Search Hermes session history via SQLite FTS5
+type: desktop
+strategy: public
+binary: sh
+detect: test -f ~/.hermes/sessions.db
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: FTS5 query string
+  limit:
+    type: int
+    default: 20
+    description: Max rows
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          db="$HOME/.hermes/sessions.db"
+          if [ ! -f "$db" ]; then
+            echo "[]"
+            exit 0
+          fi
+          # SQL-escape single quotes: ' -> ''
+          q=${UNICLI_QUERY//\'/\'\'}
+          # Force integer on limit (strip non-digits)
+          lim=${UNICLI_LIMIT//[^0-9]/}
+          : "${lim:=20}"
+          # Try FTS5 table first; fall back to LIKE if FTS table is missing
+          sqlite3 -json "$db" \
+            "SELECT id, ts, snippet(sessions_fts, -1, '<b>', '</b>', '...', 16) AS snippet FROM sessions_fts WHERE sessions_fts MATCH '$q' LIMIT $lim;" \
+            2>/dev/null \
+          || sqlite3 -json "$db" \
+            "SELECT id, ts, substr(content, 1, 200) AS snippet FROM sessions WHERE content LIKE '%$q%' LIMIT $lim;" \
+            2>/dev/null \
+          || echo "[]"
+      env:
+        UNICLI_QUERY: "${{ args.query }}"
+        UNICLI_LIMIT: "${{ args.limit }}"
+      parse: json
+
+columns: [id, ts, snippet]

package/src/adapters/hermes/skills-list.yaml

@@ -0,0 +1,30 @@
+# NousResearch/hermes-agent skills/list — read on-disk skill files.
+# Hermes stores agent skills as markdown under ~/.hermes/skills/
+#
+# Security note: no user input, so no injection surface. Uses `find`
+# directly with argv (no shell interpolation).
+site: hermes
+name: skills/list
+description: List skills installed in the local Hermes agent (~/.hermes/skills/)
+type: desktop
+strategy: public
+binary: sh
+detect: test -d ~/.hermes/skills
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          dir="$HOME/.hermes/skills"
+          if [ ! -d "$dir" ]; then
+            echo "[]"
+            exit 0
+          fi
+          find "$dir" -maxdepth 1 -name '*.md' -type f 2>/dev/null \
+            | sed "s|$dir/||" \
+            | jq -R -s 'split("\n") | map(select(length > 0)) | map({name: .})'
+      parse: json
+
+columns: [name]

package/src/adapters/hermes/skills-read.yaml

@@ -0,0 +1,46 @@
+# NousResearch/hermes-agent skills/read — read one skill file by name.
+#
+# Security: `args.name` is passed via environment variable UNICLI_NAME, not
+# template-interpolated into the shell script. Bash expands "$UNICLI_NAME"
+# inside double quotes as a literal string, so command injection is not
+# possible. Path traversal (`name=../../etc/passwd`) is blocked by the
+# case check that rejects slashes and `..` in the name.
+site: hermes
+name: skills/read
+description: Read a Hermes skill file by name (without .md extension)
+type: desktop
+strategy: public
+binary: sh
+detect: test -d ~/.hermes/skills
+
+args:
+  name:
+    type: str
+    required: true
+    positional: true
+    description: Skill name (filename without .md)
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          # Reject path traversal and anything with a slash or ".."
+          case "$UNICLI_NAME" in
+            */*|*..*|"")
+              echo '{"error":"invalid skill name"}'
+              exit 1
+              ;;
+          esac
+          file="$HOME/.hermes/skills/${UNICLI_NAME}.md"
+          if [ ! -f "$file" ]; then
+            printf '%s' "$file" | jq -Rs '{error:"not found",path:.}'
+            exit 1
+          fi
+          jq -Rs --arg name "$UNICLI_NAME" '{name:$name,content:.}' < "$file"
+      env:
+        UNICLI_NAME: "${{ args.name }}"
+      parse: json
+
+columns: [name, content]

package/src/adapters/motion-studio/component-get.yaml

@@ -0,0 +1,35 @@
+# Motion Studio (motion.dev) — fetch one example component as paste-ready code.
+# motion.dev/examples/<id> serves a Next.js page; we hit the underlying
+# data endpoint and surface the source body.
+site: motion-studio
+name: component/get
+description: Fetch a Motion (motion.dev) example component as paste-ready code
+domain: motion.dev
+type: web-api
+strategy: public
+browser: false
+
+args:
+  id:
+    type: str
+    required: true
+    positional: true
+    description: Example slug from motion.dev/examples/<id> (e.g. react-command-palette)
+
+pipeline:
+  - fetch_text:
+      url: "https://motion.dev/examples/${{ args.id }}"
+      headers:
+        Accept: text/html
+        User-Agent: Uni-CLI/0.208
+
+  - set:
+      html: ${{ ctx.data }}
+
+  - map:
+      id: ${{ args.id }}
+      url: "https://motion.dev/examples/${{ args.id }}"
+      length: ${{ vars.html.length }}
+      preview: ${{ vars.html.slice(0, 1200) }}
+
+columns: [id, url, length, preview]

package/src/adapters/openharness/memory-read.yaml

@@ -0,0 +1,51 @@
+# HKUDS/OpenHarness memory/read — read MEMORY.md and per-topic memory files
+# from a local OpenHarness install.
+#
+# Security: `args.topic` is passed via UNICLI_TOPIC env var (literal in bash).
+# Path traversal is blocked by the case check rejecting slashes and `..`.
+site: openharness
+name: memory/read
+description: Read OpenHarness MEMORY.md and per-topic memory files (~/.openharness/memory/)
+type: desktop
+strategy: public
+binary: sh
+detect: test -d ~/.openharness
+
+args:
+  topic:
+    type: str
+    required: false
+    description: Optional topic file (without .md). When omitted, returns MEMORY.md.
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          base="$HOME/.openharness"
+          if [ ! -d "$base" ]; then
+            echo '{"error":"openharness not installed","hint":"~/.openharness not found"}'
+            exit 1
+          fi
+          if [ -n "$UNICLI_TOPIC" ]; then
+            case "$UNICLI_TOPIC" in
+              */*|*..*)
+                echo '{"error":"invalid topic name"}'
+                exit 1
+                ;;
+            esac
+            file="$base/memory/${UNICLI_TOPIC}.md"
+          else
+            file="$base/MEMORY.md"
+          fi
+          if [ ! -f "$file" ]; then
+            printf '%s' "$file" | jq -Rs '{error:"not found",path:.}'
+            exit 1
+          fi
+          jq -Rs --arg path "$file" '{path:$path,content:.}' < "$file"
+      env:
+        UNICLI_TOPIC: "${{ args.topic }}"
+      parse: json
+
+columns: [path, content]

package/src/adapters/openharness/skills-list.yaml

@@ -0,0 +1,28 @@
+# HKUDS/OpenHarness skills/list — list installed OpenHarness skills.
+#
+# Security: no user input; safe argv-only call.
+site: openharness
+name: skills/list
+description: List skills installed in the local OpenHarness (~/.openharness/skills/)
+type: desktop
+strategy: public
+binary: sh
+detect: test -d ~/.openharness/skills
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          dir="$HOME/.openharness/skills"
+          if [ ! -d "$dir" ]; then
+            echo "[]"
+            exit 0
+          fi
+          find "$dir" -maxdepth 2 -name '*.md' -type f 2>/dev/null \
+            | sed "s|$dir/||" \
+            | jq -R -s 'split("\n") | map(select(length > 0)) | map({name: .})'
+      parse: json
+
+columns: [name]

package/src/adapters/renderdoc/capture-list.yaml

@@ -0,0 +1,42 @@
+# RenderDoc capture/list — enumerate captures in a directory.
+#
+# Security: `args.dir` is passed via UNICLI_DIR env var (bash literal). There's
+# no attempt to block absolute paths — this is a local directory lister and
+# the user is free to list anywhere they have read access to. The sensitive-
+# path deny list in src/permissions/sensitive-paths.ts does not apply here
+# because we're listing, not reading, and credential directories are allowed
+# to be *listed* by name (the deny list blocks read/exec of credential files).
+site: renderdoc
+name: capture/list
+description: List RenderDoc capture files (.rdc) in a directory
+type: desktop
+strategy: public
+binary: sh
+detect: which renderdoccmd
+
+args:
+  dir:
+    type: str
+    required: false
+    default: ./captures
+    description: Capture directory (defaults to ./captures)
+
+pipeline:
+  - exec:
+      command: sh
+      args:
+        - -c
+        - |
+          dir="${UNICLI_DIR:-./captures}"
+          if [ ! -d "$dir" ]; then
+            echo "[]"
+            exit 0
+          fi
+          find "$dir" -maxdepth 1 -name '*.rdc' -type f 2>/dev/null \
+            | sed "s|$dir/||" \
+            | jq -R -s 'split("\n") | map(select(length > 0)) | map({name: .})'
+      env:
+        UNICLI_DIR: "${{ args.dir }}"
+      parse: json
+
+columns: [name]

package/src/adapters/renderdoc/frame-export.yaml

@@ -0,0 +1,32 @@
+# RenderDoc frame/export — convert one capture's first frame to image via renderdoccmd.
+site: renderdoc
+name: frame/export
+description: Export the first frame from a RenderDoc capture (.rdc) as an image
+type: desktop
+strategy: public
+binary: renderdoccmd
+detect: which renderdoccmd
+
+args:
+  capture:
+    type: str
+    required: true
+    positional: true
+    description: Path to .rdc capture file
+  output:
+    type: str
+    required: true
+    description: Output image path (.png recommended)
+
+pipeline:
+  - exec:
+      command: renderdoccmd
+      args:
+        - thumb
+        - ${{ args.capture }}
+        - --out
+        - ${{ args.output }}
+      parse: text
+      timeout: 60000
+
+columns: [output]

package/src/adapters/stagehand/wrap-observe.yaml

@@ -0,0 +1,42 @@
+# Stagehand wrap/observe — subprocess wrapper around stagehand-cli.
+#
+# Stagehand exposes a vision-grounded `observe()` verb. This adapter shells
+# out to it (if installed) and parses the JSON candidates the same way
+# `unicli operate observe` does. The wrapper exists so users on Uni-CLI's
+# declarative pipelines can tap Stagehand without porting a full LLM stack.
+site: stagehand
+name: wrap/observe
+description: Run Stagehand's observe() verb against an open page (subprocess wrapper)
+type: bridge
+strategy: public
+binary: stagehand
+detect: which stagehand
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Natural-language goal (what should I click to do X?)
+  url:
+    type: str
+    required: false
+    description: URL to navigate to before observing
+  top_k:
+    type: int
+    default: 5
+    description: Max candidates
+
+pipeline:
+  - exec:
+      command: stagehand
+      args:
+        - observe
+        - --query
+        - ${{ args.query }}
+        - --top-k
+        - ${{ args.top_k }}
+      parse: json
+      timeout: 60000
+
+columns: [action, ref, selector, confidence]