@uipath/skills 1.195.0

package/commands/install-permissions.md

@@ -0,0 +1,97 @@
+---
+description: Install a curated Claude Code allowlist for safe `uip` subcommands so the agent is not prompted on every command.
+---
+
+# Install UiPath permission allowlist
+
+Help the user add a curated allowlist of safe `uip` subcommands to their Claude Code settings so the agent is not prompted on every command.
+
+**Why this command exists.** Claude Code plugins cannot ship permission rules declaratively — per the [plugins docs](https://code.claude.com/docs/en/plugins.md#ship-default-settings-with-your-plugin), only the `agent` and `subagentStatusLine` keys are honored in a plugin-shipped `settings.json`; any `permissions` block is silently ignored. Without a user-configured allowlist, every `Bash(...)` invocation prompts for approval, and a realistic Flow or RPA build runs 25+ distinct `uip` subcommands.
+
+## Steps
+
+1. **Ask which variant to install** using `AskUserQuestion`:
+   - **Full — with safety rails** (default, recommended) — writes both `allow` and `ask`. Cloud-side-effect commands (`debug` / `upload` / `publish` / `pack` / `login`) still prompt, even under `defaultMode: bypassPermissions` or `--dangerously-skip-permissions`. Prevents accidental prod publishes in YOLO mode.
+   - **Allow-only — no safety rails** — writes only the `allow` block. Power users who explicitly want zero prompts under `--dangerously-skip-permissions` pick this. Accept that a stray `uip solution publish` will execute without confirmation.
+
+2. **Ask where to install the allowlist** using a second `AskUserQuestion`:
+   - **Project — `.claude/settings.local.json`** (default) — applies only to the current project; conventionally not committed to git.
+   - **Project — `.claude/settings.json`** — applies only to the current project; usually committed.
+   - **Global — `~/.claude/settings.json`** — applies to every project.
+   - **Just print it** — output the JSON only, do not write anything.
+   - **Something else** — accept a custom path string.
+
+3. **Read the target file.** If it exists, parse the JSON strictly. If it already contains `permissions.allow` or `permissions.ask`, preserve existing entries and add only the missing ones (deduplicate by exact string). If there is no `permissions` block, add one. If the file parses as invalid JSON, abort with a clear message and ask the user to fix it manually — do not attempt to rewrite.
+
+   - If the user chose **allow-only** in step 1 and the target file already has relevant `ask` entries from a prior run, **do not remove them** — leave existing `ask` rules intact. Only the `write` side is skipped; pre-existing safety rails the user already opted into stay put.
+
+4. **Show the proposed diff** — print the delta (new entries being added to `allow`, and to `ask` if included) before writing. Do not print the full file.
+
+5. **Ask for explicit confirmation** to write. Do not write without a yes.
+
+6. **Write the file** with the merged JSON. Preserve existing formatting (indentation, key order) as much as reasonably possible.
+
+7. **Report** the path written, which variant was installed (full vs allow-only), and tell the user the new rules take effect on the next tool call — no restart required.
+
+## Recommended allowlist
+
+Split by risk. `allow` = read-only or local-only commands; `ask` = commands with cloud or filesystem side effects (keep the prompt even if a future `defaultMode` tries to auto-allow).
+
+```jsonc
+{
+  "permissions": {
+    "allow": [
+      // binary + auth status (read-only)
+      "Bash(uip --version)",
+      "Bash(uip login status)",
+      "Bash(uip login status *)",
+      "Bash(which uip)",
+
+      // discovery — registry + Integration Service + Orchestrator list ops (all read-only)
+      "Bash(uip flow registry *)",
+      "Bash(uip is *)",               // Integration Service (connections, connectors, resources, triggers)
+      "Bash(uip or folders *)",       // Orchestrator folders
+
+      // local-only flow / solution / agent scaffolding
+      "Bash(uip flow init *)",
+      "Bash(uip flow validate *)",
+      "Bash(uip flow tidy *)",
+      "Bash(uip flow node *)",
+      "Bash(uip flow edge *)",
+      "Bash(uip solution new *)",
+      "Bash(uip solution project *)",
+      "Bash(uip solution resource *)",
+      "Bash(uip agent init)",
+      "Bash(uip agent init *)",
+      "Bash(uip agent validate *)",
+
+      // RPA skill — build, get-errors, find-activities, create-project, inspect-package, etc.
+      // All local; no cloud side effects (publish goes through `uip solution upload/publish`).
+      "Bash(uip rpa *)"
+    ],
+    "ask": [
+      "Bash(uip login)",
+      "Bash(uip login --authority *)",
+      "Bash(uip flow debug)",
+      "Bash(uip flow debug *)",
+      "Bash(uip flow pack)",
+      "Bash(uip flow pack *)",
+      "Bash(uip solution upload)",
+      "Bash(uip solution upload *)",
+      "Bash(uip solution publish)",
+      "Bash(uip solution publish *)"
+    ]
+  }
+}
+```
+
+## Notes
+
+- Pattern syntax is literal-prefix + `*` wildcard with a space before `*` — see the [Claude Code settings docs](https://code.claude.com/docs/en/settings.md#permissions-configuration).
+- `Bash(uip login status *)` matches `uip login status --output json`; `Bash(uip login)` (exact, no wildcard) matches only the bare interactive login so it keeps its prompt.
+- Rule precedence in Claude Code is `deny > ask > allow`, and rules are evaluated **before** `defaultMode` / `--dangerously-skip-permissions`. So the `ask` list in the full variant still forces a prompt under YOLO mode — that is the point of it, and it is the difference between the two variants offered in step 1.
+- If the user has existing `permissions.deny` rules mentioning `uip`, do not remove them — respect explicit denials even if they conflict with the recommended allowlist. Surface the conflict in chat and ask.
+- Never modify `~/.claude/settings.json` without explicit consent — that file often contains secrets (tokens, env vars) and should not be edited casually. If the user picks the global option, re-confirm before writing.
+- The full variant's `ask` block intentionally guards `uip solution upload`, `uip flow debug`, `uip flow pack`, `uip solution publish`, and `uip login` — these produce real cloud side effects (publishing, executing flows, tenant auth). The `uipath-maestro-flow` skill's rules explicitly require user consent before cloud-executing a flow.
+- `uip agent init` is in `allow` (scaffolding — same as `uip flow init`). It does not publish to the cloud; it creates local agent project files.
+- `uip rpa *` covers the full RPA subcommand tree (`build`, `get-errors`, `create-project`, `find-activities`, `inspect-package`, `focus-activity`, etc.). None of these publish to the cloud — RPA deployment flows through `uip solution upload` / `publish` (already guarded in `ask`).

package/hooks/ensure-uip.sh

@@ -0,0 +1,220 @@
+#!/bin/bash
+# Ensures @uipath/cli and @uipath/rpa-tool are installed globally.
+# Runs once per session via the SessionStart plugin hook.
+# If npm is missing, attempts to install Node.js first.
+# Supports Windows, macOS, and Linux.
+
+set -e
+
+# ── helpers ──────────────────────────────────────────────────────────
+fail() {
+  echo "$1" >&2
+  echo "Please install Node.js from https://nodejs.org and restart your session." >&2
+  exit 2
+}
+
+is_windows() {
+  local os
+  os="$(uname -s 2>/dev/null || echo "Windows")"
+  case "$os" in
+    MINGW*|MSYS*|CYGWIN*|Windows*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+ensure_npm() {
+  command -v npm &> /dev/null && return
+
+  echo "npm not found, attempting to install Node.js..." >&2
+
+  local os
+  os="$(uname -s 2>/dev/null || echo "Windows")"
+
+  case "$os" in
+    MINGW*|MSYS*|CYGWIN*|Windows*)
+      if   command -v winget &> /dev/null; then
+        winget install --id OpenJS.NodeJS.LTS \
+          --accept-source-agreements --accept-package-agreements 2>&1
+      elif command -v choco  &> /dev/null; then choco install nodejs-lts -y 2>&1
+      elif command -v nvm    &> /dev/null; then nvm install --lts 2>&1 && nvm use --lts 2>&1
+      else fail "No package manager found (winget, choco, or nvm)."; fi
+      export PATH="$PATH:/c/Program Files/nodejs:/c/ProgramData/nvm"
+      ;;
+    Darwin*)
+      if   command -v brew &> /dev/null; then brew install node 2>&1
+      elif command -v nvm  &> /dev/null; then nvm install --lts 2>&1 && nvm use --lts 2>&1
+      else fail "No package manager found (brew or nvm)."; fi
+      ;;
+    Linux*)
+      if   command -v apt-get &> /dev/null; then sudo apt-get update -y && sudo apt-get install -y nodejs npm 2>&1
+      elif command -v dnf     &> /dev/null; then sudo dnf install -y nodejs npm 2>&1
+      elif command -v yum     &> /dev/null; then sudo yum install -y nodejs npm 2>&1
+      elif command -v pacman  &> /dev/null; then sudo pacman -Sy --noconfirm nodejs npm 2>&1
+      elif command -v nvm     &> /dev/null; then nvm install --lts 2>&1 && nvm use --lts 2>&1
+      else fail "No supported package manager found."; fi
+      ;;
+    *) fail "Unsupported platform." ;;
+  esac
+
+  hash -r 2>/dev/null
+
+  if ! command -v npm &> /dev/null; then
+    echo "Node.js was installed but npm is not yet available in this session." >&2
+    echo "Please restart your terminal, then run: npm install -g @uipath/cli" >&2
+    exit 2
+  fi
+}
+
+# Force `@uipath` to public npm. Narrowly guards users who set a custom
+# default `registry=...` in `~/.npmrc` (e.g., a corporate proxy/mirror)
+# but no `@uipath:registry=...` scope override — without this flag,
+# `outdated`, `view`, and `install` route through their default mirror,
+# which may not host `@uipath` or may serve a different `latest`.
+# `--registry=` does NOT bypass scope mappings; only the scope-specific
+# override does. Apply to `outdated` / `view` (registry lookup) and
+# `install`; `ls` reads disk and doesn't need it.
+#
+# Users WITH a non-public `@uipath:registry=...` scope mapping (UiPath
+# devs on the GitHub Packages prerelease line, private mirrors aliasing
+# the scope) are skipped earlier by `is_from_other_feed`, so this flag
+# never clobbers a deliberate non-public install — it only protects the
+# narrow "custom default registry, no scope mapping" path.
+UIPATH_REGISTRY_FLAG="--@uipath:registry=https://registry.npmjs.org/"
+
+# True if $1 is a POSIX symlink, a Windows directory symlink, OR a
+# Windows directory junction. bash `[ -L ]` catches POSIX symlinks but
+# NOT Windows junctions — and junctions are the default fallback
+# `npm link` uses on Windows when run without developer mode or admin
+# rights, so a pure `[ -L ]` check silently misses the most common
+# Windows local-link layout.
+#
+# Windows: delegate to `fsutil reparsepoint query`. Purpose-built,
+# ships with every Windows install since XP, exits 0 iff the path is
+# a reparse point (covers symlinks AND junctions), locale-independent,
+# and `query` doesn't require admin. Reachable from git-bash / MSYS /
+# Cygwin via Windows PATH lookup, and from WSL via interop (`.exe`).
+# POSIX (Linux/macOS): fall back to `[ -L ]` — junctions don't exist.
+is_symlink_or_junction() {
+  local input="$1" posix_p win_p
+  # Compute both forms: POSIX (for bash `[ -e ]`) and Windows (for fsutil).
+  # The caller may hand us either form — npm on Windows returns `C:\...`
+  # even when invoked from WSL/Cygwin/MSYS bash, while `$HOME` is POSIX.
+  # IMPORTANT: wslpath and cygpath misbehave when given the form they
+  # output (`wslpath -u /home/foo` prepends /mnt/c/, `wslpath -w C:\foo`
+  # strips backslashes). Detect input form and convert in one direction
+  # only.
+  if [[ "$input" =~ ^[A-Za-z]: ]]; then
+    win_p="$input"
+    if command -v wslpath &>/dev/null; then
+      posix_p="$(wslpath -u "$input" 2>/dev/null || echo "$input")"
+    elif command -v cygpath &>/dev/null; then
+      posix_p="$(cygpath -u "$input" 2>/dev/null || echo "$input")"
+    else
+      posix_p="$input"
+    fi
+  else
+    posix_p="$input"
+    if command -v wslpath &>/dev/null; then
+      win_p="$(wslpath -w "$input" 2>/dev/null || echo "$input")"
+    elif command -v cygpath &>/dev/null; then
+      win_p="$(cygpath -w "$input" 2>/dev/null || echo "$input")"
+    else
+      win_p="$input"
+    fi
+  fi
+  [ -e "$posix_p" ] || return 1
+  # Windows: `fsutil reparsepoint query` is purpose-built — exits 0 iff
+  # the path is a reparse point (covers symlinks AND junctions), ships
+  # with every Windows install since XP, no admin needed for query, no
+  # locale-dependent output to parse. Prefer the `.exe` form so WSL
+  # interop resolves it without relying on PATHEXT.
+  # Windows: delegate to fsutil ONLY if the input was originally a
+  # Windows-form path. In WSL with Windows interop, fsutil.exe is on
+  # PATH even when npm is Linux-installed and the package directory is
+  # a genuine Linux symlink — querying it through a `\\wsl$\...` path
+  # is unreliable, so prefer the POSIX `[ -L ]` test for POSIX inputs.
+  if [[ "$input" =~ ^[A-Za-z]: ]]; then
+    if command -v fsutil.exe &>/dev/null; then
+      fsutil.exe reparsepoint query "$win_p" &>/dev/null
+      return $?
+    fi
+    if command -v fsutil &>/dev/null; then
+      fsutil reparsepoint query "$win_p" &>/dev/null
+      return $?
+    fi
+  fi
+  # POSIX (Linux/macOS, and WSL with POSIX-form input): `[ -L ]` covers
+  # symbolic links; junctions don't exist on these platforms.
+  [ -L "$posix_p" ]
+}
+
+# Detect a local-source install via `npm link` / `bun link` (see the CLI
+# repo README, "Building from Source"). Linked installs point at a
+# working tree that is, by definition, ahead of the published `latest`
+# tag — upgrading would clobber the developer's local build with an
+# older registry version. Windows-junction handling lives in
+# `is_symlink_or_junction`.
+is_linked_package() {
+  local pkg="$1"
+  local npm_root
+  npm_root="$(npm root -g 2>/dev/null)"
+  [ -n "$npm_root" ] && is_symlink_or_junction "$npm_root/$pkg" && return 0
+  is_symlink_or_junction "$HOME/.bun/install/global/node_modules/$pkg" && return 0
+  return 1
+}
+
+# Detect a scope mapped to a non-public feed (GitHub Packages, an internal
+# Artifactory, etc.). Such builds typically carry prerelease versions ahead
+# of the public `latest` tag — forcing an upgrade against the public
+# registry would downgrade the developer's chosen feed. Signal is the
+# merged npm config for `@<scope>:registry`: if the user's `.npmrc` (any
+# level) maps the package's scope to something other than the public
+# registry, leave the install alone. Reads merged config so project/user/
+# global/env overrides are all honored. Unscoped packages → never skip.
+is_from_other_feed() {
+  local pkg="$1" scope cfg
+  case "$pkg" in
+    @*/*) scope="${pkg%%/*}" ;;
+    *) return 1 ;;
+  esac
+  cfg="$(npm config get "$scope:registry" 2>/dev/null)"
+  if [ -z "$cfg" ] || [ "$cfg" = "undefined" ]; then
+    return 1
+  fi
+  case "${cfg%/}" in
+    https://registry.npmjs.org) return 1 ;;
+    *) return 0 ;;
+  esac
+}
+
+# npm install -g always re-downloads and re-installs, even if the same version
+# is already present. This is slow for a synchronous session hook and also
+# re-triggers package lifecycle scripts. Check first, install only when needed.
+# Stay silent on the happy path: Claude Code surfaces ANY stderr from an
+# exit-0 SessionStart hook as "Failed with non-blocking status code",
+# which is misleading. Capture install output and only emit on failure.
+ensure_npm_package() {
+  local pkg="$1"
+
+  if is_linked_package "$pkg" || is_from_other_feed "$pkg"; then
+    return
+  fi
+
+  if npm ls -g "$pkg" --depth=0 &>/dev/null \
+     && [ -z "$(npm outdated -g "$pkg" $UIPATH_REGISTRY_FLAG 2>/dev/null)" ]; then
+    return
+  fi
+  
+  local output
+  if ! output="$(npm install -g $UIPATH_REGISTRY_FLAG "$pkg" 2>&1)"; then
+    echo "Failed to install $pkg:" >&2
+    echo "$output" >&2
+    echo "Please run manually: npm install -g $UIPATH_REGISTRY_FLAG $pkg" >&2
+    exit 2
+  fi
+}
+
+# ── main ─────────────────────────────────────────────────────────────
+ensure_npm
+ensure_npm_package @uipath/cli
+ensure_npm_package @uipath/rpa-tool

package/hooks/hooks.json

@@ -0,0 +1,23 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/ensure-uip.sh\"",
+            "timeout": 180,
+            "once": true,
+            "statusMessage": "Checking uip and rpa-tool installation..."
+          },
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/suggest-permissions.sh\"",
+            "timeout": 5,
+            "once": true
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/suggest-permissions.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Detects whether Claude Code has an allowlist for `uip` subcommands.
+# If none is found, prints a one-line nudge pointing at /uipath:install-permissions.
+# Non-blocking — never fails the session, even if detection fails.
+# Cross-platform (macOS, Linux, Windows via Git Bash / MSYS / Cygwin).
+
+# Only run inside a Claude Code plugin context.
+if [ -z "${CLAUDE_PLUGIN_ROOT:-}" ]; then
+  exit 0
+fi
+
+# Candidate settings files, most-to-least specific.
+candidates=()
+if [ -n "${CLAUDE_PROJECT_DIR:-}" ]; then
+  candidates+=("$CLAUDE_PROJECT_DIR/.claude/settings.local.json")
+  candidates+=("$CLAUDE_PROJECT_DIR/.claude/settings.json")
+fi
+candidates+=("$PWD/.claude/settings.local.json")
+candidates+=("$PWD/.claude/settings.json")
+candidates+=("$HOME/.claude/settings.json")
+
+# If any candidate already mentions Bash(uip...) in its permissions, stay silent.
+# Intentional simplification: this matches `allow`, `ask`, AND `deny` blocks.
+# Any explicit `uip` rule means the user has made a decision about this CLI —
+# we don't second-guess by nudging them toward a permissive allowlist.
+for f in "${candidates[@]}"; do
+  [ -f "$f" ] || continue
+  if grep -q 'Bash(uip' "$f" 2>/dev/null; then
+    exit 0
+  fi
+done
+
+# No allowlist detected — print a one-line nudge to stderr (the Claude Code
+# SessionStart convention for status messages).
+echo "uipath: To skip 25+ approval prompts per uip build, run: /uipath:install-permissions" >&2
+exit 0

package/hooks/validate-skill-descriptions.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Validate skill description lengths
+# Enforces a 1024-character limit on all SKILL.md descriptions.
+# Claude Code truncates the combined `description` + `when_to_use` at 1,536 chars
+# in the skill listing (https://code.claude.com/docs/en/skills.md). 1024 keeps
+# us comfortably under that cap while leaving headroom for `when_to_use`.
+#
+# Usage:
+#   validate-skill-descriptions.sh [file1 file2 ...]
+# If no files specified, checks staged files (for pre-commit hook)
+
+set -e
+
+LIMIT=1024
+FAILED=0
+
+# Determine which files to check
+if [ "$#" -eq 0 ]; then
+  # Pre-commit mode: check staged SKILL.md files
+  FILES=$(git diff --cached --name-only --diff-filter=ACM | grep 'skills/.*/SKILL\.md$' || true)
+else
+  # Explicit mode: use provided files
+  FILES="$@"
+fi
+
+for file in $FILES; do
+  if [ ! -f "$file" ]; then
+    continue
+  fi
+
+  # Extract description from frontmatter
+  desc=$(sed -n 's/^description: "\(.*\)"$/\1/p' "$file" | head -1)
+
+  # Also handle descriptions without surrounding quotes
+  if [ -z "$desc" ]; then
+    desc=$(sed -n 's/^description: \(.*\)$/\1/p' "$file" | head -1)
+  fi
+
+  len=${#desc}
+
+  if [ "$len" -gt "$LIMIT" ]; then
+    echo "❌ $file: description exceeds $LIMIT characters ($len chars)"
+    FAILED=1
+  else
+    echo "✓ $file: $len chars"
+  fi
+done
+
+if [ "$FAILED" -eq 1 ]; then
+  echo ""
+  echo "Skill description validation failed. Descriptions must be ≤ $LIMIT characters."
+  echo "Claude Code truncates description + when_to_use at 1,536 chars in the skill listing;"
+  echo "this repo caps at $LIMIT to leave headroom and keep descriptions focused."
+  echo "Edit the 'description' field in SKILL.md frontmatter and try again."
+  exit 1
+fi
+
+exit 0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@uipath/skills",
+  "version": "1.195.0",
+  "description": "UiPath agent skills for Claude Code, Codex, Cursor, Copilot, Gemini and OpenCode — RPA, UI automation, UI testing, coded agents/apps/workflows, and troubleshooting. Distributed as the UiPath Claude Code plugin.",
+  "author": {
+    "name": "UiPath"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/UiPath/skills",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/skills.git"
+  },
+  "keywords": [
+    "uipath",
+    "automation",
+    "rpa",
+    "workflows",
+    "skills",
+    "claude-code",
+    "agent",
+    "ui-automation",
+    "ui-testing",
+    "coded-agents",
+    "troubleshoot"
+  ],
+  "private": false,
+  "files": [
+    "skills",
+    "agents",
+    "commands",
+    "hooks",
+    "assets",
+    ".claude-plugin",
+    "version-manifest.json",
+    "README.md",
+    "LICENSE",
+    "CODEOWNERS"
+  ],
+  "scripts": {
+    "version:sync": "node scripts/sync-version.mjs",
+    "version:check": "node scripts/sync-version.mjs --check"
+  }
+}