@dsalazardev/ai-hub-cli 0.0.0-stage → 0.2.0

package/skills/shared/tauri/evals/cases.yaml

@@ -0,0 +1,46 @@
+skill: tauri
+
+should_trigger:
+  - prompt: "Scaffold a new Tauri 2 desktop app with a React frontend"
+    why: Core greenfield scaffold (create-tauri-app + src-tauri/ wiring) — the starting-shape table this skill owns.
+  - prompt: "Expose a Rust function to my frontend and call it from JS with invoke"
+    why: The commands/IPC contract — #[tauri::command], generate_handler!, camelCase/snake_case mapping.
+  - prompt: "Stream download progress from Rust to the WebView as the bytes come in"
+    why: Non-obvious — the right answer is a Channel<T>, not emit/listen events; the word "Tauri" never appears.
+  - prompt: "Lock down my Tauri app so the frontend can only read its own config directory"
+    why: The capabilities -> permissions -> scoped fs glob ($APPCONFIG) security model.
+  - prompt: "Vull fer una app d'escriptori lleugera amb Rust en lloc d'Electron"
+    why: Catalan phrasing plus the Tauri-vs-Electron boundary (small Rust+OS-WebView shell) this skill is framed around.
+  - prompt: "My Tauri command froze the whole UI while it was reading a big file"
+    why: Symptom phrasing for the blocking-the-IPC-thread anti-pattern; fix is async/spawn.
+  - prompt: "Set up the Tauri updater so my signed releases can auto-update"
+    why: Updater plugin + signing keypair, part of the bundling/distribution surface.
+
+should_not_trigger:
+  - prompt: "Build a desktop app in Electron that uses Node fs in the main process"
+    route_to: electron
+    why: Needs Node APIs in a main process and bundled Chromium — Electron's domain, explicitly the boundary case.
+  - prompt: "Set up an Expo React Native mobile app with the dev client"
+    route_to: expo
+    why: Mobile-first RN stack; Tauri's mobile is a v2 add-on to a desktop web app, not Expo tooling.
+  - prompt: "Explain Rust async lifetimes and why my future isn't Send"
+    route_to: rust
+    why: A language question about async/Send, not the desktop shell, IPC bridge, or bundler.
+  - prompt: "Style my React component grid to fill the desktop window"
+    route_to: react
+    why: Web-UI styling inside the window; the frontend framework, not the Tauri shell.
+  - prompt: "Build a single Kotlin/Compose codebase that runs on Android and desktop"
+    route_to: compose-multiplatform
+    why: Native Kotlin/Compose multiplatform, not a Rust core + web WebView.
+
+capability:
+  - scenario: "Add a `read_config` command that returns Result<String, String>, register it so the frontend can invoke it, restrict the fs scope to the app config directory, and explain the difference between a capability and a permission."
+    must_include:
+      - "#[tauri::command] annotation on the function"
+      - "Result<String, String> return (fallible -> rejected JS promise, no unwrap/panic)"
+      - "Command registered in tauri::generate_handler![...] inside invoke_handler"
+      - "A capabilities/*.json file under src-tauri/capabilities/"
+      - "fs scope glob restricted to the app config dir (e.g. $APPCONFIG/*), not the whole FS"
+      - "Default-deny note: a window with no matching capability has zero IPC access"
+      - "Explains capability = grouping of windows that grants permissions; permission = a named command set whose scope bounds the data it touches"
+      - "Frontend invoke('read_config', { ... }) call with camelCase args"

package/skills/shared/tauri/references/bundling-distribution.md

@@ -0,0 +1,129 @@
+# Tauri v2 bundling & distribution
+
+`tauri build` compiles the Rust core in release mode and produces native installers from
+your `frontendDist`. The recurring trap: unsigned binaries trigger OS warnings
+("unidentified developer", SmartScreen), so signing + (on macOS) notarization is part of
+shipping, not an afterthought.
+
+## Build targets per OS
+
+```bash
+tauri build                      # all configured bundle targets for the host OS
+tauri build --bundles dmg        # macOS: just the .dmg
+tauri build --bundles nsis,msi   # Windows: NSIS installer + MSI
+tauri build --bundles appimage,deb # Linux
+tauri build --target aarch64-apple-darwin   # cross-arch (toolchain must be installed)
+```
+
+You build **on** each target OS (or in CI runners for each); there is no single-host
+cross-build for everything because the bundler uses native tooling.
+
+| OS | Bundle formats | Signing |
+|----|----------------|---------|
+| macOS | `.app`, `.dmg` | Developer ID cert + **notarization** (Gatekeeper) |
+| Windows | NSIS (`-setup.exe`), MSI | Authenticode (SmartScreen) |
+| Linux | AppImage, `.deb`, `.rpm` | No central authority; ship checksums/GPG |
+
+## macOS signing + notarization
+
+1. Set the signing identity in config or env:
+
+```json
+// tauri.conf.json
+{ "bundle": { "macOS": { "signingIdentity": "Developer ID Application: Your Name (TEAMID)" } } }
+```
+
+2. Provide notarization credentials as env vars for `tauri build`:
+
+```bash
+export APPLE_ID="you@example.com"
+export APPLE_PASSWORD="app-specific-password"   # not your Apple ID password
+export APPLE_TEAM_ID="TEAMID"
+tauri build --bundles dmg       # signs, then submits for notarization + staples
+```
+
+Without notarization, Gatekeeper blocks the app on a clean machine even if it's signed.
+
+## Windows Authenticode
+
+```json
+// tauri.conf.json
+{ "bundle": { "windows": {
+  "certificateThumbprint": "AB12...",   // cert installed in the Windows cert store
+  "digestAlgorithm": "sha256",
+  "timestampUrl": "http://timestamp.digicert.com"
+} } }
+```
+
+Cloud/HSM signing (Azure Trusted Signing, etc.) is the modern path for CI where a local
+cert store isn't available.
+
+## Updater plugin
+
+The updater refuses unsigned updates by design — generate a keypair first.
+
+```bash
+tauri signer generate -w ~/.tauri/myapp.key   # prints the PUBLIC key to embed in config
+```
+
+```json
+// tauri.conf.json
+{ "plugins": { "updater": {
+  "pubkey": "<PUBLIC KEY FROM ABOVE>",
+  "endpoints": ["https://releases.example.com/{{target}}/{{arch}}/{{current_version}}"]
+} } }
+```
+
+- The **private** key signs each release (`TAURI_SIGNING_PRIVATE_KEY` in CI); never commit it.
+- The endpoint returns a JSON manifest with the new version, signature, and download URL.
+- Frontend: install `@tauri-apps/plugin-updater`, call `check()` then `downloadAndInstall()`.
+
+## Sidecar (embed an external binary)
+
+Ship and run an external executable alongside your app.
+
+```json
+// tauri.conf.json
+{ "bundle": { "externalBin": ["binaries/my-cli"] } }
+```
+
+Name the file per target triple (`my-cli-x86_64-apple-darwin`, etc.). Grant the
+`shell:allow-execute` permission scoped to that sidecar to invoke it from Rust/JS.
+
+## GitHub Actions release matrix (sketch)
+
+One job per OS, each runs `tauri build` and uploads artifacts. Pair with the
+`github-actions` skill for the CI mechanics.
+
+```yaml
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - { platform: macos-latest,   args: '--target aarch64-apple-darwin' }
+          - { platform: macos-latest,   args: '--target x86_64-apple-darwin' }
+          - { platform: ubuntu-22.04,   args: '' }
+          - { platform: windows-latest, args: '' }
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: npm ci && npm run tauri build -- ${{ matrix.args }}
+        env:
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+```
+
+On Linux runners install the WebKitGTK system deps before building (the Tauri docs list the
+exact apt packages for your Ubuntu version).
+
+## Checklist
+
+- [ ] Build per target OS (host or CI runner), not a single cross-build.
+- [ ] macOS signed **and** notarized; Windows Authenticode-signed.
+- [ ] Updater keypair generated; private key only in CI secrets, public key in config.
+- [ ] Sidecar binaries named per target triple + scoped `shell:allow-execute`.
+- [ ] Linux WebKitGTK deps installed in CI.

package/skills/shared/tauri/references/security.md

@@ -0,0 +1,143 @@
+# Tauri v2 security — capabilities, permissions, scopes, CSP, isolation
+
+The IPC bridge is default-deny. Nothing in the frontend can call Rust until a **capability**
+applies to that window and grants the matching **permissions**, and a permission's **scope**
+bounds what data/paths/hosts the command may touch. Get this layer right and an XSS in the
+WebView can only do what you explicitly granted.
+
+## The chain
+
+```text
+capability  ──applies to──▶  one or more windows/webviews
+    │
+    └─grants─▶  permissions  ──each maps──▶  scope (paths, hosts, …)
+```
+
+A webview matching **no** capability has **zero** IPC access. There is no global allow.
+
+## Capability file anatomy
+
+Files live in `src-tauri/capabilities/*.json` and are merged at build time.
+
+```json
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "main-capability",
+  "description": "What the main window is allowed to do.",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "dialog:allow-open",
+    {
+      "identifier": "fs:allow-read-text-file",
+      "allow": [{ "path": "$APPCONFIG/*" }]
+    }
+  ]
+}
+```
+
+- `identifier` — unique per file.
+- `windows` — glob of window labels this capability binds to (`["main"]`, `["settings-*"]`).
+- `permissions` — either a string id (`plugin:permission-name`, e.g. `fs:allow-read-file`)
+  or an object that **scopes** the permission with `allow` / `deny`.
+- `platforms` (optional) — restrict to `["macOS", "windows", "linux", "iOS", "android"]`.
+
+## Permission identifiers
+
+Format is `plugin:permission`. Conventions:
+
+- `core:default` — the baseline core permission set; safe to keep.
+- `fs:allow-read-text-file`, `fs:allow-write-text-file`, `fs:allow-mkdir`, … — granular.
+- `fs:default` / `http:default` — convenience bundles; **prefer granular** so you only
+  grant the verbs you use.
+- `deny-*` variants exist and win over `allow-*` — use to carve exceptions out of a bundle.
+
+## Scope globs (fs / http)
+
+Scopes restrict the *data* a permission reaches. They take path or URL globs, with
+path variables resolved at runtime.
+
+```json
+// fs: read only inside the app config dir, never the home dir
+{ "identifier": "fs:allow-read-text-file",
+  "allow": [{ "path": "$APPCONFIG/*" }],
+  "deny":  [{ "path": "$HOME/.ssh/*" }] }
+```
+
+Common path variables: `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`,
+`$HOME`, `$DOCUMENT`, `$DOWNLOAD`, `$RESOURCE`, `$TEMP`. Prefer the `$APP*` set — they
+resolve under the app's own sandbox dir.
+
+```json
+// http: only your API, nothing else
+{ "identifier": "http:default",
+  "allow": [{ "url": "https://api.example.com/*" }] }
+```
+
+`deny` always overrides `allow`. A permission with neither is effectively "any" — always
+add an `allow`.
+
+## Per-window privilege separation
+
+Split capabilities so a low-trust window can't reach high-trust commands. Give the main UI
+one capability and an embedded/third-party webview a far narrower one (or none).
+
+```json
+// capabilities/embed.json — a webview showing third-party content gets almost nothing
+{ "identifier": "embed-capability", "windows": ["embed-*"], "permissions": ["core:default"] }
+```
+
+## CSP
+
+CSP is enforced **only if set** in config. Until then the WebView runs whatever it loads.
+
+```json
+// tauri.conf.json — prod: lock to self; Tauri injects nonces/hashes for your assets
+{ "app": { "security": {
+  "csp": "default-src 'self'; img-src 'self' data:; connect-src 'self' https://api.example.com"
+} } }
+```
+
+- Local scripts/styles are **hashed**; external ones get a **per-load nonce** — both only
+  once a CSP string exists.
+- In dev you typically need a looser `connect-src` for the Vite/HMR dev server; keep the
+  strict policy for the production build (`devCsp` vs `csp` if you split them).
+- A `<meta>` CSP tag does not cover the initial document — set CSP in config, not just markup.
+
+## Isolation pattern
+
+Use when frontend code might be untrusted — third-party npm deps, plugins, anything you
+don't fully control. It injects a sandboxed `<iframe>` that intercepts every IPC message
+before it reaches Rust, so you can validate or reject it. Messages are encrypted with the
+browser's SubtleCrypto using an AES key **regenerated on each app start**.
+
+1. Set the pattern in `tauri.conf.json`:
+
+```json
+{ "app": { "security": { "pattern": {
+  "use": "isolation",
+  "options": { "dir": "../dist-isolation" }
+} } } }
+```
+
+2. Provide `dist-isolation/index.html` loading a hook that inspects each message:
+
+```javascript
+// dist-isolation/index.js
+window.__TAURI_ISOLATION_HOOK__ = (payload) => {
+  // inspect / sanitize / reject before it reaches Rust
+  return payload;
+};
+```
+
+Cost: a small per-message crypto overhead. Worth it whenever the frontend supply chain is
+not fully trusted.
+
+## Checklist
+
+- [ ] Every window that calls Rust has a capability; no global allow.
+- [ ] `fs`/`http` permissions carry an `allow` scope; sensitive paths in `deny`.
+- [ ] Granular permissions, not `*:default` bundles, where practical.
+- [ ] CSP set in config for the production build.
+- [ ] Isolation pattern on if frontend deps/plugins are untrusted.
+- [ ] No secrets in the frontend bundle — they live in Rust.

package/skills/shared/tauri/scripts/verify.sh

@@ -0,0 +1,178 @@
+#!/usr/bin/env bash
+# verify.sh — read-only static lint for a Tauri v2 project (src-tauri/ tree).
+#
+# Mirrors the SKILL.md anti-patterns so the advice is checkable. It scans the
+# target for the failure modes people actually ship. It is a LINT — no build,
+# no network, no Cargo, deterministic, CI-safe. Read-only: never writes anything.
+#
+# Severity model (per the spec — heuristic + advisory):
+#   WARN  — likely-wrong, advisory. Does NOT fail the run.
+#   FAIL  — a hard structural break (v1 allowlist in a v2 config). Fails the run.
+#
+# Checks:
+#   1. FAIL  legacy v1 `"allowlist"` key in tauri.conf.json (v2 uses capabilities).
+#   2. WARN  src-tauri/ present but no capabilities/*.json — default-deny means zero IPC,
+#            usually a mistake unless the app makes no Rust calls.
+#   3. WARN  a capability lists no permissions (empty/absent "permissions").
+#   4. WARN  a command in generate_handler![...] has no matching #[tauri::command] fn.
+#   5. WARN  a fallible-looking command (read/write/fetch/load/save/delete/open) whose
+#            signature returns no `Result` — likely should return Result<T, E>.
+#   6. WARN  no CSP set anywhere in tauri.conf.json (app.security.csp).
+#
+# Exits 0 on a clean OR empty target, and on WARN-only. Exits 1 only on a FAIL.
+# Usage: verify.sh [TARGET_DIR]   (default ".")
+
+set -uo pipefail
+
+TARGET="${1:-.}"
+fail=0
+warned=0
+
+warn() { printf 'WARN [%s] %s — %s\n' "$1" "$2" "$3" >&2; warned=1; }
+hard() { printf 'FAIL [%s] %s — %s\n' "$1" "$2" "$3" >&2; fail=1; }
+note() { printf '%s\n' "$1"; }
+
+if [ ! -e "$TARGET" ]; then
+  note "verify: target does not exist: $TARGET — nothing to check."
+  exit 0
+fi
+
+# Locate the src-tauri dir (the target may be it, contain it, or be a single file).
+srctauri=""
+if [ -d "$TARGET/src-tauri" ]; then
+  srctauri="$TARGET/src-tauri"
+elif [ -d "$TARGET" ] && [ "$(basename "$TARGET")" = "src-tauri" ]; then
+  srctauri="$TARGET"
+else
+  found=$(find "$TARGET" -type d -name src-tauri -not -path '*/.git/*' 2>/dev/null | head -n1)
+  [ -n "$found" ] && srctauri="$found"
+fi
+
+# --- tauri.conf.json checks (run wherever a conf is found) ---------------------
+conf_files=()
+while IFS= read -r f; do conf_files+=("$f"); done < <(
+  find "$TARGET" -type f -name 'tauri.conf.json' -not -path '*/.git/*' 2>/dev/null
+)
+
+if [ "${#conf_files[@]}" -eq 0 ] && [ -z "$srctauri" ]; then
+  note "verify: no Tauri project found under $TARGET (no src-tauri/, no tauri.conf.json) — nothing to check."
+  exit 0
+fi
+
+for conf in "${conf_files[@]}"; do
+  content=$(tr -d '\r' < "$conf")
+
+  # Rule 1 (FAIL): v1 allowlist key.
+  if printf '%s' "$content" | grep -Eq '"allowlist"[[:space:]]*:'; then
+    ln=$(grep -nE '"allowlist"[[:space:]]*:' "$conf" | head -n1 | cut -d: -f1)
+    hard "v1-allowlist" "$conf:${ln:-?}" 'v1 "allowlist" key in a v2 config — replace with capabilities/*.json'
+  fi
+
+  # Rule 6 (WARN): no CSP.
+  if ! printf '%s' "$content" | grep -Eq '"csp"[[:space:]]*:'; then
+    warn "no-csp" "$conf" 'no app.security.csp set — the WebView runs any loaded script; set a CSP for prod'
+  fi
+done
+
+# --- capabilities checks -------------------------------------------------------
+if [ -n "$srctauri" ]; then
+  capdir="$srctauri/capabilities"
+  cap_files=()
+  if [ -d "$capdir" ]; then
+    while IFS= read -r f; do cap_files+=("$f"); done < <(
+      find "$capdir" -type f -name '*.json' 2>/dev/null
+    )
+  fi
+
+  # Rule 2 (WARN): src-tauri present but no capability files.
+  if [ "${#cap_files[@]}" -eq 0 ]; then
+    warn "no-capabilities" "$srctauri" 'no capabilities/*.json — default-deny means zero IPC access; add a scoped capability'
+  fi
+
+  # Rule 3 (WARN): a capability with no permissions.
+  for cap in ${cap_files[@]+"${cap_files[@]}"}; do
+    capc=$(tr -d '\r' < "$cap")
+    if ! printf '%s' "$capc" | grep -Eq '"permissions"[[:space:]]*:[[:space:]]*\['; then
+      warn "cap-no-perms" "$cap" 'capability has no "permissions" array — it grants nothing (or is malformed)'
+    elif printf '%s' "$capc" | grep -Eq '"permissions"[[:space:]]*:[[:space:]]*\[[[:space:]]*\]'; then
+      warn "cap-no-perms" "$cap" 'capability "permissions" is empty — grants nothing'
+    fi
+  done
+fi
+
+# --- command checks (Rust) -----------------------------------------------------
+if [ -n "$srctauri" ]; then
+  rs_files=()
+  while IFS= read -r f; do rs_files+=("$f"); done < <(
+    find "$srctauri" -type f -name '*.rs' -not -path '*/target/*' 2>/dev/null
+  )
+
+  # Gather the set of #[tauri::command] fn names and their (multi-line) signatures.
+  declared_names=""
+  for rs in ${rs_files[@]+"${rs_files[@]}"}; do
+    # Find lines with the command attribute, then the fn name on a following line.
+    # awk: when we see the attribute, capture the next fn <name>.
+    while IFS= read -r name; do
+      [ -n "$name" ] && declared_names="$declared_names $name"
+    done < <(awk '
+      /#\[tauri::command/ { armed=1; next }
+      armed && /fn[ \t]+[A-Za-z_][A-Za-z0-9_]*/ {
+        match($0, /fn[ \t]+[A-Za-z_][A-Za-z0-9_]*/)
+        s=substr($0, RSTART, RLENGTH); sub(/fn[ \t]+/, "", s); print s; armed=0
+      }
+      armed && NF==0 { next }
+    ' "$rs")
+  done
+
+  # Rule 4 (WARN): names inside generate_handler![...] with no declared command.
+  for rs in ${rs_files[@]+"${rs_files[@]}"}; do
+    # Extract the comma list between generate_handler![ and the closing ].
+    handler=$(tr -d '\r' < "$rs" | tr '\n' ' ' | grep -oE 'generate_handler!\[[^]]*\]' || true)
+    [ -z "$handler" ] && continue
+    inner=$(printf '%s' "$handler" | sed -E 's/.*generate_handler!\[//; s/\].*//')
+    # Split on commas, strip module paths (mod::cmd -> cmd) and whitespace.
+    IFS=',' read -ra regs <<< "$inner"
+    for r in "${regs[@]}"; do
+      r=$(printf '%s' "$r" | tr -d ' \t')
+      r="${r##*::}"
+      [ -z "$r" ] && continue
+      case " $declared_names " in
+        *" $r "*) : ;;
+        *) warn "unregistered-cmd" "$rs" "generate_handler! lists '$r' but no #[tauri::command] fn '$r' was found" ;;
+      esac
+    done
+  done
+
+  # Rule 5 (WARN): fallible-looking command without Result in its signature.
+  for rs in ${rs_files[@]+"${rs_files[@]}"}; do
+    while IFS= read -r nm; do
+      [ -n "$nm" ] && warn "no-result" "$rs" "command '$nm' looks fallible but returns no Result<T, E> — Err should become a rejected JS promise"
+    done < <(awk '
+      /#\[tauri::command/ { armed=1; sig=""; next }
+      armed {
+        sig = sig " " $0
+        if (sig ~ /\{/ || sig ~ /;/) {
+          # signature complete (body brace or decl end)
+          if (match(sig, /fn[ \t]+[A-Za-z_][A-Za-z0-9_]*/)) {
+            nm=substr(sig, RSTART, RLENGTH); sub(/fn[ \t]+/, "", nm)
+            if (nm ~ /^(read|write|fetch|load|save|delete|open|get|put|post)_/ && sig !~ /Result[ \t]*</) {
+              print nm
+            }
+          }
+          armed=0
+        }
+      }
+    ' "$rs")
+  done
+fi
+
+if [ "$fail" -ne 0 ]; then
+  note "verify: Tauri lint FAILED — fix the structural issue(s) above."
+  exit 1
+fi
+if [ "$warned" -ne 0 ]; then
+  note "verify: Tauri lint passed with advisory warnings (review above; not fatal)."
+  exit 0
+fi
+note "verify: Tauri project passes the static lint."
+exit 0