Skip to content
Back to search

clawscan

Composable security scanning harness for agent skills

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/openclaw/clawscan with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/openclaw/clawscan'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/openclaw--clawscan/badge.svg)](/listings/openclaw--clawscan)

HTML

<a href="/listings/openclaw--clawscan"><img src="/api/listings/openclaw--clawscan/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install ClawScan:

npm install -g @openclaw/clawscan

Command-backed scanners and judges run in ClawScan's Docker runtime by default, so keep Docker running for local scans.

Run NVIDIA SkillSpector and Cisco Skill Scanner against a local `skills/` folder:

clawscan --scanner skillspector --scanner cisco

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 356 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # ClawScan 📡
  2. ClawScan is a composable security scanning harness for agent skills.
  3. Run a suite of skill security scanners, pass the results to a judge harness, and compare against multiple skill security benchmarks.
  4. [![CI](https://github.com/openclaw/clawscan/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/openclaw/clawscan/actions/workflows/ci.yml?query=branch%3Amain)
  5. [![Release](https://github.com/openclaw/clawscan/actions/workflows/release.yml/badge.svg)](https://github.com/openclaw/clawscan/actions/workflows/release.yml)
  6. [![Latest release](https://img.shields.io/github/v/release/openclaw/clawscan)](https://github.com/openclaw/clawscan/releases)
  7. ## Quick Start
  8. Install ClawScan:
  9. ```bash
  10. npm install -g @openclaw/clawscan
  11. ```
  12. The macOS binaries support macOS 13 or later on Apple Silicon and Intel. CI uses
  13. the Apple Silicon `xcode-27` runner and verifies x86_64 binaries under Rosetta.
  14. Release and npm builds pin the macOS 13 deployment target and check both binaries' minimum OS metadata.
  15. Source builds require Go 1.27.1 or later; the module selects the patched Go 1.27.3 build toolchain.
  16. Command-backed scanners and judges run in ClawScan's Docker runtime by default,
  17. so keep Docker running for local scans.
  18. Run NVIDIA SkillSpector and Cisco Skill Scanner against a local `skills/` folder:
  19. ```bash
  20. clawscan --scanner skillspector --scanner cisco
  21. ```
  22. ## Scan a known malicious skill
  23. This example scans Trail of Bits' [`csv-summarizer`](https://github.com/trailofbits/overtly-malicious-skills/tree/4ffbf9461ef0505f9ce76a0d3694a18ec33ea531/skills/csv-summarizer) skill, which claims to summarize a CSV file but also prints every environment variable when run.
  24. ```bash
  25. git clone https://github.com/trailofbits/overtly-malicious-skills.git /tmp/overtly-malicious-skills
  26. cd /tmp/overtly-malicious-skills
  27. git checkout 4ffbf9461ef0505f9ce76a0d3694a18ec33ea531
  28. clawscan skills/csv-summarizer \
  29. --scanner skillspector \
  30. --scanner cisco \
  31. --output /tmp/clawscan-csv-summarizer.json
  32. ```
  33. Sample findings:
  34. ```txt
  35. targets: 1
  36. scanner_completed: 2
  37. scanner_failed: 0
  38. scanner_skipped: 0
  39. issues_found: 2
  40. gate: pass
  41. errors: 0
  42. full_results: /tmp/clawscan-csv-summarizer.json
  43. ```
  44. The results bundle keeps the top-level artifact plus per-scanner JSON reports.
  45. <details>
  46. <summary>Artifact excerpt</summary>
  47. ```json
  48. {
  49. "schemaVersion": "clawscan-run-v1",
  50. "target": "skills/csv-summarizer",
  51. "scanners": {
  52. "cisco": {
  53. "status": "completed",
  54. "durationMs": 42,
  55. "outputPath": "clawscan-csv-summarizer/skills/csv-summarizer/cisco.json",
  56. "isSafe": true,
  57. "maxSeverity": "SAFE",
  58. "findingsCount": 0
  59. },
  60. "skillspector": {
  61. "status": "completed",
  62. "durationMs": 42,
  63. "outputPath": "clawscan-csv-summarizer/skills/csv-summarizer/skillspector.json",
  64. "severity": "MEDIUM",
  65. "score": 31,
  66. "recommendation": "CAUTION",
  67. "issues": [
  68. {
  69. "id": "LP3",
  70. "severity": "MEDIUM",
  71. "file": "SKILL.md"
  72. },
  73. {
  74. "id": "E2",
  75. "severity": "HIGH",
  76. "file": "scripts/summarize.py"
  77. }
  78. ]
  79. }
  80. }
  81. }
  82. ```
  83. </details>
  84. ## Motivation
  85. Agent-skill security is new and fast-moving, with researchers and companies
  86. exploring many promising scanners, datasets, and judge harnesses. In our
  87. [ClawHub Security Signals paper](https://arxiv.org/html/2606.01494v1), we found
  88. that combining multiple scanners with a configurable judge works better than
  89. relying on any single scanner.
  90. ClawScan turns that approach into a repeatable CLI. It includes a built-in `clawhub` profile, a saved scanner-and-judge configuration that matches what ClawHub runs in production, so researchers can reproduce results, test improvements, and help improve detection against the weekly refreshed ClawHub security-signals dataset.
  91. ## Commands
  92. | Command family | Use |
  93. | --- | --- |
  94. | `clawscan <target> --scanner <id>` | Run one or more scanners against an explicit skill or OpenClaw plugin target. Omit `<target>` to scan child skill directories under `./skills`; plugins are never auto-discovered. |
  95. | `clawscan scanners [list\|<scanner-id>]` | Discover supported scanner IDs, required env vars, upstream links, descriptions, and install guidance. |
  96. | `clawscan profiles [-v]` | Inspect built-in profiles; `-v` prints the catalog as YAML. |
  97. | `clawscan benchmark [list\|<benchmark-id>]` | Discover or run supported benchmarks through a selected scanner/profile/judge setup. |
  98. | `clawscan install <scanner-id> [...]` | Install or verify local scanner dependencies where ClawScan has registry-backed install plans. |
  99. | `clawscan openclaw-install-policy` | Act as an external OpenClaw `security.installPolicy.exec` command. Reads the staged install request from stdin and returns allow/warn/block JSON. |
  100. ## OpenClaw install policy
  101. ClawScan integrates with OpenClaw at the operator-owned
  102. `security.installPolicy` boundary. It does not register an install hook or
  103. depend on plugin activation. The policy command scans the staged `sourcePath`
  104. for both skills and plugins before OpenClaw commits a supported install or
  105. update.
  106. See [docs/openclaw-install-policy.md](docs/openclaw-install-policy.md) for the
  107. trusted executable setup, configuration, payload contract, and scope.
  108. ## Scanners
  109. `--scanner` selects a scanner adapter to run, writes its raw JSON evidence into
  110. the results artifact, and can be repeated to compare multiple scanners in one
  111. run:
  112. ```bash
  113. clawscan ./my-skill \
  114. --scanner skillspector \
  115. --scanner cisco
  116. ```
  117. Discover the scanner catalog from the CLI:
  118. ```bash
  119. clawscan scanners
  120. clawscan scanners skillspector
  121. ```
  122. ### Available scanners
  123. > **Want to add your scanner to the list?** Follow the guide in [docs/scanners.md](docs/scanners.md#adding-a-built-in-scanner-adapter)
  124. | ID | Name | Repo | Description | Required env vars | Local dependency setup |
  125. | --- | --- | --- | --- | --- | --- |
  126. | `agentverus` | AgentVerus | [repo](https://github.com/agentverus/agentverus-scanner) | Local file or directory scanner invoked through agentverus-scanner. | none | `npm install --save-dev agentverus-scanner` |
  127. | `aig` | Tencent AI-Infra-Guard | [repo](https://github.com/Tencent/AI-Infra-Guard/tree/main/skill-scan) | Tencent Zhuque Lab's local directory scanner invoked through `aig-skill-scan`. Produces SARIF 2.1.0 with SkillTrustBench T01-T09 evidence. | `LLM_API_KEY` or `OPENAI_API_KEY`<br><details><summary>Optional config</summary><code>DEFAULT_MODEL</code>, <code>REASONING_EFFORT</code> (requires the patched runtime), <code>DEFAULT_BASE_URL</code>, <code>DEFAULT_MODEL_CONTEXT_WINDOW</code>, <code>LOG_LEVEL</code>.</details> | `pip install aig-skill-scan` |
  128. | `aig-mcp` | Tencent AI-Infra-Guard MCP scanner | [repo](https://github.com/Tencent/AI-Infra-Guard/tree/main/mcp-scan) | Tencent Zhuque Lab's LLM-driven MCP server code audit invoked through `aig-mcp-scan`, run on OpenClaw plugin targets only (skill, file and URL targets are skipped). Audits a bounded temporary copy of the whole plugin without `node_modules`, using an OpenClaw plugin audit prompt, and produces SARIF 2.1.0 with MCP01-MCP10 evidence. Runs in the Docker sandbox, whose runtime image removes the agent's shell and file-write tools. | `LLM_API_KEY` or `OPENAI_API_KEY`<br><details><summary>Optional config</summary><code>DEFAULT_MODEL</code>, <code>DEFAULT_BASE_URL</code> (same defaults as <code>aig</code>), <code>DEFAULT_MODEL_CONTEXT_WINDOW</code>, <code>AIG_MCP_SCAN_ALLOW_HOST_EXEC=1</code> (required with <code>--sandbox off</code>).</details> | runtime image (patched `aig-mcp-scan==0.2.0`); `pip install aig-mcp-scan==0.2.0` is unpatched |
  129. | `cisco` | Cisco AI Defense skill-scanner | [repo](https://github.com/cisco-ai-defense/skill-scanner) | Local file or directory scanner invoked through `skill-scanner` with JSON report output. Optional upstream env vars enable LLM, VirusTotal, and Cisco AI Defense analyzers. | none<br><details><summary>Optional config</summary><code>SKILL_SCANNER_LLM_API_KEY</code>, <code>SKILL_SCANNER_LLM_PROVIDER</code>, <code>SKILL_SCANNER_LLM_MODEL</code>, <code>SKILL_SCANNER_LLM_BASE_URL</code>, <code>SKILL_SCANNER_LLM_USER</code>, <code>SKILL_SCANNER_LLM_API_VERSION</code>, <code>SKILL_SCANNER_LLM_FORCE_JSON_OBJECT</code>, <code>SKILL_SCANNER_META_LLM_API_KEY</code>, <code>SKILL_SCANNER_META_LLM_MODEL</code>, <code>SKILL_SCANNER_META_LLM_BASE_URL</code>, <code>SKILL_SCANNER_META_LLM_API_VERSION</code>, <code>AWS_PROFILE</code>, <code>AWS_REGION</code>, <code>GOOGLE_APPLICATION_CREDENTIALS</code>, <code>VIRUSTOTAL_API_KEY</code>, <code>AI_DEFENSE_API_KEY</code>, <code>AI_DEFENSE_API_URL</code>.</details> | `uv pip install cisco-ai-skill-scanner` |
  130. | `relyable` | Relyable | [repo](https://github.com/veriker/relyable) | Functional re-derivation evidence: does the skill still do what its docs claim, recomputed? Emits the strongest grade that applies. `exogenous`: a declared `rederive.json` property manifest (idempotence / round-trip), with both sides of the relation computed from the skill's own code and the result mutation-tested against vacuity. `self_spec`: re-runs the author's own committed oracle (shipped tests or documented I/O examples). `cold_golden`: when an LLM key is set, a code-blind model infers goldens from SKILL.md alone and abstains unless the docs pin exact behavior; divergences are reported as unconfirmed, never as accusations. `non_rederivable`: the honest floor, never a fabricated pass. Functional axis only; complements the security scanners and does not detect malware or prompt injection. Skill code runs only inside the Docker sandbox (or with an explicit opt-in), in a scrubbed environment, and the scanner fails closed otherwise. Not preinstalled in the `clawscan-runtime` image. | none<br><details><summary>Optional config</summary><code>RELYABLE_SCAN_ALLOW_HOST_EXEC</code> — explicit ack that the host is disposable when running with <code>--sandbox off</code>.<br><br><code>RELYABLE_LLM_API_KEY</code> (+ <code>RELYABLE_LLM_PROVIDER</code> <code>anthropic|openai</code>, <code>RELYABLE_LLM_MODEL</code>, <code>RELYABLE_LLM_BASE_URL</code>) — explicit per-scanner opt-in that enables the <code>cold_golden</code> lane; key presence only is ever recorded in the payload. Generic <code>ANTHROPIC_API_KEY</code>/<code>OPENAI_API_KEY</code> are honored by standalone <code>relyable-scan</code> but are deliberately not auto-forwarded by ClawScan.</details> | `clawscan install relyable` — not preinstalled in the runtime image |
  131. | `skillspector` | NVIDIA SkillSpector | [repo](https://github.com/NVIDIA/skillspector) | Local skill or OpenClaw plugin file/directory scanner. Uses LLM mode when provider env vars are set; otherwise runs with `--no-llm`. | none<br><details><summary>Optional config</summary><code>SKILLSPECTOR_PROVIDER</code>, <code>SKILLSPECTOR_MODEL</code>, <code>SKILLSPECTOR_REASONING_EFFORT</code>, <code>SKILLSPECTOR_TEMPERATURE</code>, <code>SKILLSPECTOR_SEED</code>, <code>SKILLSPECTOR_MODEL_REGISTRY</code>, <code>SKILLSPECTOR_LOG_LEVEL</code>, <code>SKILLSPECTOR_SSL_VERIFY</code>, <code>NVIDIA_INFERENCE_KEY</code>, <code>OPENAI_API_KEY</code>, <code>OPENAI_BASE_URL</code>, <code>ANTHROPIC_API_KEY</code>, <code>ANTHROPIC_PROXY_ENDPOINT_URL</code>, <code>ANTHROPIC_PROXY_API_KEY</code>, <code>ANTHROPIC_PROXY_API_VERSION</code>.</details> | `uv tool install git+https://github.com/NVIDIA/skillspector.git` |
  132. | `snyk` | Snyk Agent Scan | [repo](https://github.com/snyk/agent-scan) | Local skill scanner invoked through `uvx snyk-agent-scan`. | `SNYK_TOKEN` | verifies `uvx` launcher |
  133. | `socket` | Socket CLI | [repo](https://github.com/SocketDev/socket-cli) | Local file or directory scanner using Socket's public CLI full-scan path. | `SOCKET_CLI_API_TOKEN` | `npm install -g socket` |
  134. Starting in `v0.1.2`, the built-in `aig` scanner uses Tencent's local
  135. `aig-skill-scan` package instead of the legacy A.I.G Docker/API service.
  136. Replace `AIG_MODEL` with `DEFAULT_MODEL`, `AIG_MODEL_BASE_URL` with
  137. `DEFAULT_BASE_URL`, and `AIG_MODEL_API_KEY` with `LLM_API_KEY` (or
  138. `OPENAI_API_KEY`). `AIG_BASE_URL` and `AIG_API_KEY` are no longer used.
  139. The local scanner accepts directory targets only; materialize URL or file inputs
  140. as a skill directory before scanning them with `aig`.
  141. ## Profiles
  142. `--profile` runs a saved scanner and judge configuration, such as the built-in
  143. `clawhub` profile that matches ClawHub's production scanner suite and Codex
  144. judge harness:
  145. ```bash
  146. clawscan ./my-skill --profile clawhub
  147. ```
  148. The same profile accepts an explicit OpenClaw plugin directory (or its
  149. `openclaw.plugin.json` manifest). For plugins it runs only `aig-mcp`, Tencent
  150. A.I.G's MCP code audit, over the whole plugin minus `node_modules` (embedded
  151. skills and `dist/`/`build/` output included), and renders the bundled judge
  152. prompt with `packageRelease` target context and that one raw SARIF result; see
  153. [docs/scanners.md](docs/scanners.md#plugin-code-audit-with-aig-mcp).
  154. Inspect the built-in profile catalog:
  155. ```bash
  156. clawscan profiles
  157. clawscan profiles -v
  158. ```
  159. ### Available profiles
  160. | Profile | Scanners | Judge |
  161. | --- | --- | --- |
  162. | `clawhub` | skills: `skillspector`, `aig`; plugins: `aig-mcp` | Evidence-only Codex `gpt-6.1-sol` verdict from scanner results (no artifact copy; file, shell, web and code-execution tools disabled), then an evidence-only Codex `gpt-6-luna` low-effort overview |
  163. | `clawhub-aig` | `skillspector`, `aig` | Same judge and overview as `clawhub` |
  164. | `openclaw-install-policy` | `skillspector` | none |
  165. The two ClawHub profiles explicitly configure the OpenAI scanner lanes with
  166. `scannerEnvDefaults`: SkillSpector uses `SKILLSPECTOR_PROVIDER=openai`,
  167. `SKILLSPECTOR_MODEL=gpt-6.1-sol`, and `SKILLSPECTOR_REASONING_EFFORT=medium`;
  168. A.I.G uses `DEFAULT_MODEL=gpt-6.1-sol` and `REASONING_EFFORT=medium` with OpenAI
  169. credentials (`aig-mcp` uses the same model and endpoint defaults, but not
  170. `REASONING_EFFORT` or the Standard-tier control). The verdict comes from an
  171. evidence-only Codex run (`gpt-6.1-sol`, high reasoning) that sees scanner
  172. results only: no artifact copy, and file, shell, web and code-execution tools
  173. disabled. A separate
  174. evidence-only Codex overview step (`gpt-6-luna`, low reasoning, Standard
  175. service) writes the readable summary and never changes the verdict. Credentials
  176. stay in the environment. See [judge harness](docs/judge.md#clawhub-judge); the
  177. Decisions API judge remains available through `--judge`.
  178. Explicit model/provider/effort environment overrides win. A different
  179. SkillSpector provider retains its own model defaults. A.I.G with a dedicated
  180. `LLM_API_KEY` retains its provider defaults unless `DEFAULT_BASE_URL` explicitly
  181. selects `https://api.openai.com/v1`; third-party endpoints are never redirected.
  182. An explicit alternative model does not inherit the profile's Sol effort.
  183. Generic `--scanner` runs and project profiles without `scannerEnvDefaults` keep
  184. their existing provider choices. The supported defaults are only the five model
  185. control names above, not arbitrary environment variables or credentials.
  186. Use the runtime image built from the same source revision: its pinned NVIDIA
  187. SkillSpector and Tencent Zhuque Lab A.I.G integrations include narrow Responses
  188. API compatibility patches. Sol tool calls are not supported on Chat Completions;
  189. changing only the model environment or reusing the old 0.2.0 runtime is insufficient.
  190. See [scanner runtime compatibility](docs/scanner-runtime.md).
  191. ### Build a custom profile with `.clawscan.yml`
  192. Custom profiles can be created in `.clawscan.yml`.
  193. This is useful for version controlling iterations on your profile, creating multiple profiles to run over the same skills, etc
  194. ```yaml
  195. # yaml-language-server: $schema=https://raw.githubusercontent.com/openclaw/clawscan/main/schemas/clawscan.schema.json
  196. version: 1
  197. profiles:
  198. review:
  199. scanners:
  200. - skillspector
  201. - snyk
  202. sandbox:
  203. env:
  204. - OPENAI_API_KEY
  205. - CODEX_API_KEY
  206. judge:
  207. command: >
  208. codex exec --cd {{ workspace }}
  209. --model gpt-5.5
  210. --output-last-message {{ output }}
  211. - < {{ prompt:./prompt.md }}
  212. ```
  213. The published schema provides editor completion and catches invalid profile
  214. fields before a scan starts. ClawScan also validates every config at runtime.
  215. ## Judge Harness
  216. `--judge` hands scanner evidence to an external agent command so it can inspect
  217. the skill, do its own research in the scan workspace, and write a final JSON
  218. verdict:
  219. ```bash
  220. clawscan ./my-skill \
  221. --scanner skillspector \
  222. --judge 'codex exec --cd {{ workspace }} --output-last-message {{ output }} - < {{ prompt:./prompt.md }}'
  223. ```
  224. Supported `--judge` placeholders:
  225. | Placeholder | Meaning |
  226. | --- | --- |
  227. | `{{ workspace }}` | Temporary directory containing the copied skill, scanner JSON, and metadata. |
  228. | `{{ judge_sandbox }}` | `danger-full-access` inside ClawScan's Docker sandbox, otherwise `read-only`. |
  229. | `{{ prompt }}` | Render `./prompt.md` and pass the rendered prompt file path. |
  230. | `{{ prompt:<path> }}` | Render a specific prompt template and pass that file path. |
  231. | `{{ output_schema }}` | Copy `./schema.json` into the workspace and pass that file path. |
  232. | `{{ output_schema:<path> }}` | Copy a specific schema file and pass that file path. |
  233. | `{{ output }}` | File path where the judge should write its final JSON object. |
  234. The judge is any command that reads the prompt and writes a JSON object matching
  235. the output schema. ClawScan is judge-agnostic: judge-specific checks, such as an
  236. input-size limit, belong inside the judge command, and a failed judge command
  237. keeps its own error. A profile can add an `overview.command` that writes a
  238. readable summary after the verdict; it never changes the verdict or gate. See
  239. [judge harness](docs/judge.md).
  240. ## Sandbox
  241. ClawScan runs command-backed scanners and judges in
  242. `ghcr.io/openclaw/clawscan-runtime:latest` by default:
  243. ```bash
  244. clawscan ./my-skill --scanner skillspector
  245. ```
  246. Use `--sandbox off` only in an already-isolated environment, or when you have
  247. installed scanner dependencies on the host with `clawscan install`. Use
  248. `--sandbox-env <NAME>` or a profile `sandbox.env` list to pass judge-specific
  249. environment variables into the container.
  250. ## Benchmarks
  251. `clawscan benchmark <benchmark-id>` runs a supported benchmark through the
  252. selected scanners and optional judge harness:
  253. ```bash
  254. clawscan benchmark list
  255. clawscan benchmark SkillTrustBench \
  256. --profile clawhub \
  257. --output ./artifacts/skilltrustbench-clawhub.json
  258. ```
  259. Use `--ids <path-or-url>` with SkillTrustBench to run a fixed subset from a
  260. plain text ID list or JSONL rows with an `id` field.
  261. ### Available benchmarks
  262. | Benchmark | ID | Source |
  263. | --- | --- | --- |
  264. | ClawHub Security Signals | `clawhub-security-signals` | [Hugging Face](https://huggingface.co/datasets/OpenClaw/clawhub-security-signals) |
  265. | SkillTrustBench | `SkillTrustBench` | [Hugging Face](https://huggingface.co/datasets/cuhk-zhuque/SkillTrustBench) |
  266. ### Submitting a patch to the `clawhub` profile
  267. If you are a security researcher who found malicious skills live on ClawHub and
  268. want to improve the production scanner so it catches them, use GitHub private
  269. vulnerability reporting for the sensitive details and open a PR containing only
  270. a candidate `proposals/<GHSA-ID>/clawscan.yml` config. For a guided walkthrough,
  271. ask Codex:
  272. ```text
  273. Use $report-clawhub-malicious-skill to walk me through reporting a malicious ClawHub skill.
  274. ```
  275. ### ClawHub Profile Baseline
  276. Maintainers validate accepted `clawhub` profile proposals against the public
  277. SkillTrustBench leaderboard subset. The maintainer gate writes compact dated
  278. baselines under `benchmarks/skilltrustbench-leaderboard-10pct/`; the latest
  279. `YYYY-MM-DD.json` file is the current accepted baseline.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.