Skip to content
Back to search

DBPilot

Self-hosted database performance diagnostics for SQL Server, MySQL & PostgreSQL: trends, AAS insight, Top SQL, plan-change tracking, blocking & deadlock analysis. Single-process deploy, built-in MCP server for AI agents.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/skychensky--dbpilot/badge.svg)](/listings/skychensky--dbpilot)

HTML

<a href="/listings/skychensky--dbpilot"><img src="/api/listings/skychensky--dbpilot/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.

Fastest path: NuGet packages (frontend embedded — no Node.js). Requires .NET SDK 8.0+ — packages run on .NET 8 or later.

1. Create a host project and add the metapackage:

mkdir dbpilot-demo && cd dbpilot-demo
dotnet new web
dotnet add package DBPilot

> Don't name the host project `dbpilot` or `DBPilot.*` — it collides with the NuGet package and restore fails (NU1108).

2. Replace `Program.cs` with:

using DBPilot.AspNetCore.Extension;
using DBPilot.Core.Providers;

var builder = WebApplication.CreateBuilder(args);
builder.AddDBPilot(o => o.PlatformEngine = DbpilotEngine.Sqlite);  // metadata store: SQLite, zero dependencies

var app = builder.Build();
app.UseDBPilot();
app.Run();

3. Replace `appsettings.json` with (SQLite flavor):

{
  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",
      "Override": { "Microsoft": "Warning", "System": "Warning" }
    }
  },
  "DBPilot": {
    "ConnectionString": "Data Source=dbpilot_platform.db",
    "Mcp": { "ApiKey": "<random key; non-empty enables MCP, empty = off>" },
    "Auth": {
      "Username": "admin",
      "PasswordHash": "pbkdf2$100000$IOaBWezPYRnzEbBWYwLxZA==$xBWm8jjDfanDmyRttfnZoG4MIk8lcF0UnDbpjJuWaEU=",
      "Secret": "<your master key (>= 32-char random string)>"
    }
  },
  "AllowedHosts": "*"
}

- `ConnectionString` and `Auth:Secret` are required — the SQLite file and schema are created on startup; the master key is generated as shown [below](#password-and-master-key). - `PasswordHash` is the hash of the default password `dbpilot@2026`; keep it to log in with the default.

4. Run:

dotnet run    # → http://localhost:5000

5. Log in with `admin` / `dbpilot@2026` (**change it after deployment**), then register your first instance: **Instances → Add** → Test connection → Enable. Real-time pages work immediately; history accumulates.

**Metadata store**: for SQL Server / MySQL / PostgreSQL, switch `PlatformEngine` and the connection string — that's all; registered instances are unaffected. SQLite suits evaluation and single-machine use; prefer a server engine for production (and multi-process roles). Ready-made hosts: [`samples/`](samples/) (SqlServer :5200 / MySql :5201 / Sqlite :5203 / PostgreSql :5204).

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 · 365 lines · 1 finding marked

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

  1. # DBPilot
  2. **Self-hosted database autonomous diagnostics platform**.
  3. [![NuGet](https://img.shields.io/nuget/v/DBPilot.svg)](https://www.nuget.org/packages/DBPilot)
  4. [![NuGet downloads](https://img.shields.io/nuget/dt/DBPilot.svg)](https://www.nuget.org/packages/DBPilot)
  5. [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE.txt)
  6. [![.NET](https://img.shields.io/badge/.NET-8%2B-512BD4.svg)](https://dotnet.microsoft.com/download/dotnet/8.0)
  7. [![Engines](https://img.shields.io/badge/engines-SQL%20Server%20%7C%20MySQL%20%7C%20PostgreSQL-0db7a4.svg)](#engine-support-matrix)
  8. DBPilot continuously samples your instances and serves the day-to-day DBA workflow in one web console: performance trends and insight (AAS load decomposition), Top SQL, query plan change tracking, missing-index advice, index usage & fragmentation, blocking analysis, deadlock analysis, and slow query logs.
  9. [简体中文](README.zh-CN.md)
  10. ![Overview](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/overview.png)
  11. ## Contents
  12. - [Highlights](#highlights)
  13. - [Screenshots](#screenshots)
  14. - [Quick start](#quick-start)
  15. - [Password and master key](#password-and-master-key)
  16. - [Configuration](#configuration-appsettingsjson)
  17. - [Building from source](#building-from-source)
  18. - [Architecture](#architecture)
  19. - [Features](#features)
  20. - [Engine support matrix](#engine-support-matrix)
  21. - [AI diagnostics (MCP Server)](#ai-diagnostics-mcp-server)
  22. - [Overhead on monitored instances](#overhead-on-monitored-instances)
  23. - [Embedding via NuGet](#embedding-via-nuget)
  24. - [FAQ](#faq)
  25. - [License](#license)
  26. ## Highlights
  27. - **Single-process deployment** — one .NET process (8.0+) + one metadata DB, schema auto-created on startup (SQL Server / MySQL / PostgreSQL / SQLite).
  28. - **Monitors three engines** — SQL Server 2008–2022, MySQL 8.0+, PostgreSQL 13+. Monitoring and metadata-store engines are independent axes: any combination works.
  29. - **<1% CPU overhead** — collectors read only in-memory metadata views (DMVs / `pg_stat_*` / `performance_schema`); business tables are never scanned.
  30. - **AI-ready** — built-in read-only MCP Server exposes 11 diagnostic tools to AI agents (Claude Code, Codex CLI). Just ask: *"did any SQL slow down in the last hour?"*
  31. - **Capability-driven UI** — features without an equivalent data source hide or degrade per engine (PostgreSQL gets deadlock *trends* instead of event details); APIs answer with actionable messages.
  32. ## Screenshots
  33. | Performance insight (AAS) | Performance trends |
  34. |---|---|
  35. | ![Performance insight](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/insight.png) | ![Performance trends](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/metrics.png) |
  36. | Deadlock analysis | Deadlock event detail |
  37. |---|---|
  38. | ![Deadlocks](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/deadlocks.png) | ![Deadlock event detail](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/deadlocks-detail.png) |
  39. | Blocking analysis | Blocking chain detail |
  40. |---|---|
  41. | ![Blocking](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/blocking.png) | ![Blocking chain detail](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/blocking-detail.png) |
  42. | Index usage | Slow query log |
  43. |---|---|
  44. | ![Index usage](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/index-usage.png) | ![Slow SQL](https://raw.githubusercontent.com/SkyChenSky/DBPilot/main/docs/images/slowsql.png) |
  45. ## Quick start
  46. Fastest path: NuGet packages (frontend embedded — no Node.js). Requires .NET SDK 8.0+ — packages run on .NET 8 or later.
  47. 1. Create a host project and add the metapackage:
  48. ```bash
  49. mkdir dbpilot-demo && cd dbpilot-demo
  50. dotnet new web
  51. dotnet add package DBPilot
  52. ```
  53. > Don't name the host project `dbpilot` or `DBPilot.*` — it collides with the NuGet package and restore fails (NU1108).
  54. 2. Replace `Program.cs` with:
  55. ```csharp
  56. using DBPilot.AspNetCore.Extension;
  57. using DBPilot.Core.Providers;
  58. var builder = WebApplication.CreateBuilder(args);
  59. builder.AddDBPilot(o => o.PlatformEngine = DbpilotEngine.Sqlite); // metadata store: SQLite, zero dependencies
  60. var app = builder.Build();
  61. app.UseDBPilot();
  62. app.Run();
  63. ```
  64. 3. Replace `appsettings.json` with (SQLite flavor):
  65. ```json
  66. {
  67. "Serilog": {
  68. "MinimumLevel": {
  69. "Default": "Information",
  70. "Override": { "Microsoft": "Warning", "System": "Warning" }
  71. }
  72. },
  73. "DBPilot": {
  74. "ConnectionString": "Data Source=dbpilot_platform.db",
  75. "Mcp": { "ApiKey": "<random key; non-empty enables MCP, empty = off>" },
  76. "Auth": {
  77. "Username": "admin",
  78. "PasswordHash": "pbkdf2$100000$IOaBWezPYRnzEbBWYwLxZA==$xBWm8jjDfanDmyRttfnZoG4MIk8lcF0UnDbpjJuWaEU=",
    • Note: Contains a long base64-looking blob — not necessarily malicious, but worth inspecting what it decodes to
    • Line 103 on GitHub
  79. "Secret": "<your master key (>= 32-char random string)>"
  80. }
  81. },
  82. "AllowedHosts": "*"
  83. }
  84. ```
  85. - `ConnectionString` and `Auth:Secret` are required — the SQLite file and schema are created on startup; the master key is generated as shown [below](#password-and-master-key).
  86. - `PasswordHash` is the hash of the default password `dbpilot@2026`; keep it to log in with the default.
  87. 4. Run:
  88. ```bash
  89. dotnet run # → http://localhost:5000
  90. ```
  91. 5. Log in with `admin` / `dbpilot@2026` (**change it after deployment**), then register your first instance: **Instances → Add** → Test connection → Enable. Real-time pages work immediately; history accumulates.
  92. **Metadata store**: for SQL Server / MySQL / PostgreSQL, switch `PlatformEngine` and the connection string — that's all; registered instances are unaffected. SQLite suits evaluation and single-machine use; prefer a server engine for production (and multi-process roles). Ready-made hosts: [`samples/`](samples/) (SqlServer :5200 / MySql :5201 / Sqlite :5203 / PostgreSql :5204).
  93. ## Password and master key
  94. **Change the login password**: passwords are PBKDF2 hashes in `DBPilot:Auth:PasswordHash` — replace the hash to change the password.
  95. 1. Create a two-line `hash.cs` **outside any project directory** (your home dir works). Inside a project, `dotnet run` would treat it as an argument. File-based apps with `#:package` need .NET SDK 10; on SDK 8 use the repo-clone alternative below:
  96. ```csharp
  97. #:package DBPilot.Core@0.5.5
  98. Console.WriteLine(DBPilot.Core.Auth.PasswordHasher.Hash(args[0]));
  99. ```
  100. 2. Run it — the whole output line is the new hash:
  101. ```bash
  102. dotnet run hash.cs <new-password>
  103. ```
  104. 3. Paste it into `DBPilot:Auth:PasswordHash`, restart.
  105. Repo clones can skip the steps: `dotnet run --project samples/DBPilot.Sample.SqlServer -- --hash <new-password>`.
  106. **Master key** (`Auth:Secret`, or env `DBPILOT_MASTER_KEY`) — required, exactly two uses:
  107. | Purpose | What it does | If you change it |
  108. |---|---|---|
  109. | Login-cookie signing | issues/validates login tickets (HMAC-SHA256) | all sessions logged out; log in again |
  110. | Instance-credential encryption | instance passwords stored AES-256-GCM-encrypted in the metadata DB | **old ciphertext is undecryptable, no recovery** — re-enter each instance's password in the UI |
  111. Hence startup fails without it, and you should **not change it once in use**. Generate one:
  112. ```bash
  113. openssl rand -base64 32 # Linux / macOS / Git Bash
  114. # PowerShell: [guid]::NewGuid().ToString("N") + [guid]::NewGuid().ToString("N")
  115. ```
  116. ## Configuration (appsettings.json)
  117. Two required keys + one required value — `DBPilot:ConnectionString`, `DBPilot:PlatformEngine`, and a master key (`Auth:Secret` or env `DBPILOT_MASTER_KEY`). Missing → startup error; everything else is optional with defaults.
  118. | Key | Required | Notes |
  119. |---|---|---|
  120. | `DBPilot:ConnectionString` | **yes** | metadata DB connection string; schema auto-created on startup |
  121. | `DBPilot:PlatformEngine` | **yes** | `sqlserver` / `mysql` / `postgresql` / `sqlite`; in code: `o.PlatformEngine = DbpilotEngine.SqlServer`. Independent of which engines you monitor |
  122. | `DBPilot:Auth:Secret` | **yes** (or env) | master key — signs login cookies, encrypts instance credentials; ≥32-char random string |
  123. | `DBPILOT_MASTER_KEY` (env) | **yes** (or Secret) | env form of the master key, container-friendly; config value takes precedence |
  124. | `DBPilot:Auth:Username` / `PasswordHash` | no | login account (default `admin`) / password hash (default `dbpilot@2026`) |
  125. | `DBPilot:Mcp:ApiKey` | no | MCP Server switch (non-empty = on) |
  126. | `DBPilot:Roles` | no | process roles (Web / Collector, both by default); multi-process = 1 collector + N web fronts — two collectors on one metadata DB double-collect |
  127. | `DBPilot:Jobs` | no | per-collector switch & cron; empty value = disable that collector |
  128. | `DBPilot:Retention` / `DBPilot:Collect` | no | retention days (auto-clean) / parallelism & backoff |
  129. | `DBPilot:AutoInitSchema` | no | auto-create schema on startup (default true; set false when DBAs own the schema); versioned incremental migrations (`dbpilot_schema_version`) run alongside on upgrade |
  130. | `DBPilot:TopSqlExcludePatterns` | no | Top SQL noise filter (LIKE patterns); default set built in, explicit empty array clears it |
  131. Monitored instances are never configured here — they live in the UI, credentials encrypted in the metadata DB.
  132. ## Building from source
  133. Additionally requires **Node.js 20+** (the embedded web UI comes from the frontend build; NuGet packages ship it prebuilt).
  134. ```bash
  135. git clone https://github.com/SkyChenSky/DBPilot.git
  136. cd DBPilot
  137. scripts\run\setup.bat # frontend build + compile + sample appsettings.json (default SqlServer host; pass MySql / Sqlite / PostgreSql to switch)
  138. # edit samples/DBPilot.Sample.SqlServer/appsettings.json — fill in the connection string and Auth:Secret
  139. dotnet run --project samples/DBPilot.Sample.SqlServer # → http://localhost:5200
  140. ```
  141. Non-Windows / manual equivalent:
  142. ```bash
  143. cd web && npm install && npm run build
  144. cd .. && dotnet build
  145. cp samples/DBPilot.Sample.SqlServer/appsettings.template.json samples/DBPilot.Sample.SqlServer/appsettings.json
  146. ```
  147. Day-to-day dev: `scripts\run\dev.bat`, or two terminals — `dotnet watch --project samples/DBPilot.Sample.SqlServer` (backend, Swagger at `/swagger`) + `cd web && npm run dev` (frontend → http://localhost:5173). Tests: `scripts\run\test.bat` (compile + unit tests + frontend build). Self-test load scripts in `scripts/test/` — never run them against production databases.
  148. ## Architecture
  149. ```mermaid
  150. flowchart LR
  151. subgraph browser["Browser"]
  152. ui["Web console"]
  153. end
  154. subgraph host["DBPilot service (single process)"]
  155. api["Web API + MCP Server"]
  156. sched["Background collectors (Quartz)"]
  157. webhost["Static UI hosting"]
  158. end
  159. subgraph platform["Metadata DB (schema auto-created)"]
  160. tables["Historical data"]
  161. end
  162. subgraph monitored["Monitored instances (any number)"]
  163. dmv["DMV / XE / pg_stat_* / performance_schema"]
  164. end
  165. ui --> webhost
  166. ui -->|API| api
  167. sched -->|scheduled sampling| dmv
  168. sched --> tables
  169. api --> tables
  170. api -->|real-time queries| dmv
  171. ```
  172. The browser talks only to the DBPilot service: real-time pages query instances directly, history pages read the metadata DB — both share the same data conventions (noise exclusion, fingerprinting, time windows).
  173. ## Features
  174. | Page | What it answers |
  175. |---|---|
  176. | **Overview** | instance health at a glance — metric cards with sparklines, recent events, Top SQL digest |
  177. | **Performance trends** | CPU / memory / PLE / QPS·TPS / IO / disk, 10s granularity (30-day retention, auto down-sampling); event overlay for deadlocks / slow SQL / plan changes |
  178. | **Performance insight** | Average Active Sessions decomposed into CPU / lock / IO / waits — which resource is saturated, and the SQL statements contributing the load |
  179. | **Top SQL** | real-time leaderboard + history trends, merged by fingerprint; one-click noise exclusion |
  180. | **Query plans** | plan versions snapshotted automatically; changes raise events with before/after comparison, plan tree and XML |
  181. | **Missing indexes** | optimizer recommendations ranked by impact, with CREATE scripts and overlap hints |
  182. | **Index usage / fragmentation** | unused-index detection with drop scripts; fragmentation scan with REBUILD / REORGANIZE scripts |
  183. | **Blocking analysis** | real-time blocking tree (head blocker, chain, wait times) + historical statistics |
  184. | **Deadlock analysis** | captured automatically; graph view of the cycle, statements and lock relationships |
  185. | **Slow query log** | above-threshold statements archived automatically — full text, duration, IO, fingerprint |
  186. ## Engine support matrix
  187. | Capability | SQL Server | MySQL 8.0+ | PostgreSQL 13+ |
  188. |---|---|---|---|
  189. | Sessions / blocking (real-time tree + history) | ✅ | ✅ | ✅ (`pg_stat_activity` + `pg_blocking_pids`) |
  190. | Top SQL (fingerprinted) | ✅ | ✅ (`performance_schema` digest) | ✅ (`pg_stat_statements`) |
  191. | Slow query log | ✅ (XE events) | ✅ (`mysql.slow_log` table) | ◐ template leaderboard |
  192. | Performance trends | ✅ | ◐ (no OS CPU/memory, PLE, compile counters) | ◐ (QPS is transaction-scope) |
  193. | Deadlock analysis | ✅ event details + graph | ❌ | ◐ trend only |
  194. | Query plan snapshots / change tracking | ✅ | ❌ | ❌ |
  195. | Missing index advice | ✅ | ❌ | ❌ |
  196. | Index usage | ✅ | ◐ (unused-index detection conservative) | ◐ (unused indexes reliably detectable) |
  197. | Fragmentation scan | ✅ | ❌ | ❌ |
  198. | Index disable script | ✅ | ✅ (`INVISIBLE`) | ❌ |
  199. | Disk usage | ✅ volume-level | ◐ database-level | ◐ database-level |
  200. **Metadata store**: SQL Server / MySQL / PostgreSQL / SQLite — independent from the monitored engines, any combination (SQLite = single-executable + single-file embedded deployment).
  201. Prerequisites are minimal and self-checked by the connection-test wizard: MySQL needs `performance_schema` + slow-log settings; PostgreSQL needs the `pg_stat_statements` extension; SQL Server works from 2008 up (deadlock capture rides the built-in `system_health` session). The wizard tells you exactly what to change when something is missing.
  202. ## AI diagnostics (MCP Server)
  203. A read-only MCP Server (`/mcp`, Streamable HTTP + API key) hands the platform's evidence — metrics, slow SQL, deadlocks, blocking, indexes — to AI agents as 11 read-only tools. Agents never connect to your databases directly; every call is audit-logged.
  204. Enable (off by default; non-empty `ApiKey` = on):
  205. ```json
  206. "DBPilot": { "Mcp": { "ApiKey": "a sufficiently random key" } }
  207. ```
  208. ```bash
  209. claude mcp add --transport http dbpilot http://localhost:5200/mcp --header "X-Api-Key: <your-key>"
  210. ```
  211. Then just ask: *"use dbpilot to check the instance load over the last hour — any SQL getting slower?"* Add `--scope user` to make it global.
  212. **Codex CLI** (`~/.codex/config.toml`):
  213. ```toml
  214. [mcp_servers.dbpilot]
  215. url = "http://localhost:5200/mcp"
  216. [mcp_servers.dbpilot.http_headers]
  217. X-Api-Key = "<your-key>"
  218. ```
  219. Example projects live in [`examples/`](examples/): `DBPilot.McpConsole` (command-line diagnostic console) and `DBPilot.Scenarios` (fault-drill project), both referencing the official NuGet packages.
  220. ## Overhead on monitored instances
  221. **<1% CPU, zero disk pressure.** Collectors read in-memory metadata views only — no business-table scans, no physical IO, no locks on user objects.
  222. | Collector | Frequency | Cost |
  223. |---|---|---|
  224. | Sessions / metrics / Top SQL delta / deadlocks / slow SQL | 10–60s | millisecond-level metadata queries; XE cursors near zero when idle |
  225. | Query plan snapshots | 5 min | plan XML fetched once per fingerprint (XML generation is the expensive part) |
  226. | Index snapshots (incl. fragmentation) | daily 03:10 | heaviest tick, scheduled at night |
  227. | History writes | — | always to the metadata DB, never to monitored instances |
  228. Built-in mitigations: XE predicates exclude the platform's own traffic, every cron is configurable, instances disable individually, failed connections back off. Same DMV-polling path as SQL Server's own `system_health` and AWS Performance Insights.
  229. Verify it yourself — after a day of running, the monitoring account's accumulated CPU seconds is the true cost:
  230. ```sql
  231. SELECT login_name, SUM(cpu_time)/1000 AS cpu_seconds_total
  232. FROM sys.dm_exec_sessions
  233. WHERE host_process_id IS NOT NULL
  234. GROUP BY login_name;
  235. ```
  236. ## Embedding via NuGet
  237. Published on [nuget.org](https://www.nuget.org/packages?q=DBPilot):
  238. ```bash
  239. dotnet add package DBPilot # metapackage: AspNetCore + all engines, one line
  240. # or pick what you need:
  241. dotnet add package DBPilot.AspNetCore # API / MCP / auth / scheduling / embedded frontend
  242. dotnet add package DBPilot.SqlServer # engines — SqlServer / MySql / PostgreSql (monitor + storage)
  243. dotnet add package DBPilot.MySql # and Sqlite (storage only, embedded deployments)
  244. dotnet add package DBPilot.Sqlite
  245. ```
  246. ```csharp
  247. using DBPilot.AspNetCore.Extension;
  248. using DBPilot.Core.Providers;
  249. var builder = WebApplication.CreateBuilder(args);
  250. builder.AddDBPilot(o =>
  251. {
  252. o.PlatformEngine = DbpilotEngine.SqlServer; // no default — set explicitly (or via DBPilot:PlatformEngine)
  253. // o.WebOnly(); // delegate sets only what you want to change
  254. });
  255. var app = builder.Build();
  256. app.UseDBPilot();
  257. app.Run();
  258. ```
  259. - **Zero wiring** — referenced engine packages register themselves (output-directory scan); instances route by their `engine` column. Explicit registration (`AddDbpilotSqlServer()`) mixes in and is required for single-file publishes.
  260. - Package graph: `DBPilot.AspNetCore → Core → Storage → Common`; engine packages depend on Core + Storage.
  261. - Frontend assets ship twice — `buildTransitive` targets copy into `wwwroot`, plus an embedded-manifest fallback so the UI works even with an empty wwwroot.
  262. - Fine-grained methods (`AddDbpilotWeb` / `AddDbpilotMcp` / `AddDbpilotQuartz` / ...) remain available.
  263. ## FAQ
  264. | Symptom | Fix |
  265. |---|---|
  266. | Startup warning `平台库结构初始化失败` (schema init failed) | check `DBPilot:ConnectionString` and DB reachability; ignorable without persistence |
  267. | Home page 404 / stale UI | frontend not built — `cd web && npm install && npm run build`, rebuild, restart |
  268. | Startup error "DBPilot 主密钥未配置" (master key missing) | set `DBPilot:Auth:Secret` or env `DBPILOT_MASTER_KEY` |
  269. | Collector error `The computed authentication tag did not match...` | master key doesn't match the stored credential ciphertext (changed after instances were registered) — re-enter each instance's password in the UI |
  270. | Performance insight empty | instance enabled and collecting? Insights need ~1 minute of samples |
  271. | Deadlock / slow SQL events not showing yet | event files buffer ~1 minute — wait and refresh |
  272. ## License
  273. [Apache-2.0](LICENSE.txt)

Ratings and comments

Sign in to rate this skill.

Sign in

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