Skip to content
Back to search

atlassian-dc-mcp

MCP servers for the Atlassian products (Bitbucket, Confluence, JIRA) of the Data Center version

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/b1ff/atlassian-dc-mcp 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/b1ff/atlassian-dc-mcp'

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/b1ff--atlassian-dc-mcp/badge.svg)](/listings/b1ff--atlassian-dc-mcp)

HTML

<a href="/listings/b1ff--atlassian-dc-mcp"><img src="/api/listings/b1ff--atlassian-dc-mcp/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.

Each package ships an interactive `setup` subcommand that stores your credentials in the most secure place available on your OS. Run it once per product:

npx @atlassian-dc-mcp/jira setup
npx @atlassian-dc-mcp/confluence setup
npx @atlassian-dc-mcp/bitbucket setup

The setup CLI prompts for host, API base path, default page size, and API token. Before saving, it validates obvious input mistakes and performs a timed authenticated request to the selected Atlassian product, so a bad host, base path, or token is caught during setup.

CLI flags and non-interactive mode

Setup accepts flags so you can prefill values or skip prompts entirely (useful for scripted bootstrap, CI, or remote sessions). Run `npx @atlassian-dc-mcp/<product> setup --help` for the full list.

| Flag | Short | Description | |------|-------|-------------| | `--host <value>` | `-H` | Host, e.g. `jira.example.com` | | `--api-base-path <value>` | `-b` | API base path or full URL | | `--token <value>` | `-t` | API token | | `--default-page-size <n>` | `-s` | Default page size (positive integer) | | `--non-interactive` | `-n` | Skip prompts; fail if a required value cannot be resolved | | `--help` | `-h` | Show usage and exit |

In interactive mode, any flag you pass prefills its prompt (so e.g. `--host` skips the host prompt but still asks for the rest). In `--non-interactive` mode, setup resolves anything missing from existing configuration (process env, `~/.atlassian-dc-mcp/<product>.env`, or macOS Keychain) and exits non-zero if a host (or full-URL `--api-base-path`) and token cannot be found. An existing token is reused when `--token` is omitted.

# Scripted, no prompts, write everything from flags
npx @atlassian-dc-mcp/jira setup --non-interactive \
  --host jira.example.com \
  --token "$JIRA_TOKEN"

# Re-validate the existing token without re-entering it
npx @atlassian-dc-mcp/jira setup --non-interactive --host jira.example.com

Credential validation behaves differently between modes: interactive mode offers retry/save-anyway prompts on failure, while `--non-interactive` exits with code 1 on the first validation failure so it can be used as a CI gate.

Token storage:

- **macOS** — written to the login Keychain via `/usr/bin/security` (service `atlassian-dc-mcp`, account `<product>-token`). - **Linux** — written to `~/.atlassian-dc-mcp/<product>.env` with POSIX mode `0600` (read/write for your user only; other local user accounts cannot read it). - **Windows** — written to `%USERPROFILE%\.atlassian-dc-mcp\<product>.env`. Node passes the mode bits but Windows ignores them, so the file inherits the ACL of your user profile directory — typically readable only by your user, SYSTEM, and Administrators.

Non-secret fields (host, API base path, default page size) are always written to the home file — `~/.atlassian-dc-mcp/<product>.env` on macOS/Linux, `%USERPROFILE%\.atlassian-dc-mcp\<product>.env` on Windows. After a successful Keychain write, the token line is cleared from the home file so there is never a second copy in a less-secure place.

Once setup has run, the MCP servers can boot with no environment variables at all:

{
  "mcpServers": {
    "atlassian-jira-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/jira"] },
    "atlassian-confluence-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/confluence"] },
    "atlassian-bitbucket-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/bitbucket"] }
  }
}

You can still pass credentials via environment variables or `ATLASSIAN_DC_MCP_CONFIG_FILE` as shown in the sections below — they take precedence over values saved by setup.

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 · 447 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. [![MSeeP.ai Security Assessment Badge](https://mseep.net/pr/b1ff-atlassian-dc-mcp-badge.png)](https://mseep.ai/app/b1ff-atlassian-dc-mcp)
  2. # Atlassian Data Center MCP
  3. > **Note:** This is a community-maintained project and is **not affiliated with, endorsed by, or supported by Atlassian**.
  4. > Use at your own discretion.
  5. This project provides a Model Context Protocol (MCP) integration for Atlassian Data Center products, including Jira, Confluence, and Bitbucket.
  6. ## Quick Setup
  7. Each package ships an interactive `setup` subcommand that stores your credentials in the most secure place available on your OS. Run it once per product:
  8. ```bash
  9. npx @atlassian-dc-mcp/jira setup
  10. npx @atlassian-dc-mcp/confluence setup
  11. npx @atlassian-dc-mcp/bitbucket setup
  12. ```
  13. The setup CLI prompts for host, API base path, default page size, and API token. Before saving, it validates obvious input mistakes and performs a timed authenticated request to the selected Atlassian product, so a bad host, base path, or token is caught during setup.
  14. ### CLI flags and non-interactive mode
  15. Setup accepts flags so you can prefill values or skip prompts entirely (useful for scripted bootstrap, CI, or remote sessions). Run `npx @atlassian-dc-mcp/<product> setup --help` for the full list.
  16. | Flag | Short | Description |
  17. |------|-------|-------------|
  18. | `--host <value>` | `-H` | Host, e.g. `jira.example.com` |
  19. | `--api-base-path <value>` | `-b` | API base path or full URL |
  20. | `--token <value>` | `-t` | API token |
  21. | `--default-page-size <n>` | `-s` | Default page size (positive integer) |
  22. | `--non-interactive` | `-n` | Skip prompts; fail if a required value cannot be resolved |
  23. | `--help` | `-h` | Show usage and exit |
  24. In interactive mode, any flag you pass prefills its prompt (so e.g. `--host` skips the host prompt but still asks for the rest). In `--non-interactive` mode, setup resolves anything missing from existing configuration (process env, `~/.atlassian-dc-mcp/<product>.env`, or macOS Keychain) and exits non-zero if a host (or full-URL `--api-base-path`) and token cannot be found. An existing token is reused when `--token` is omitted.
  25. ```bash
  26. # Scripted, no prompts, write everything from flags
  27. npx @atlassian-dc-mcp/jira setup --non-interactive \
  28. --host jira.example.com \
  29. --token "$JIRA_TOKEN"
  30. # Re-validate the existing token without re-entering it
  31. npx @atlassian-dc-mcp/jira setup --non-interactive --host jira.example.com
  32. ```
  33. Credential validation behaves differently between modes: interactive mode offers retry/save-anyway prompts on failure, while `--non-interactive` exits with code 1 on the first validation failure so it can be used as a CI gate.
  34. Token storage:
  35. - **macOS** — written to the login Keychain via `/usr/bin/security` (service `atlassian-dc-mcp`, account `<product>-token`).
  36. - **Linux** — written to `~/.atlassian-dc-mcp/<product>.env` with POSIX mode `0600` (read/write for your user only; other local user accounts cannot read it).
  37. - **Windows** — written to `%USERPROFILE%\.atlassian-dc-mcp\<product>.env`. Node passes the mode bits but Windows ignores them, so the file inherits the ACL of your user profile directory — typically readable only by your user, SYSTEM, and Administrators.
  38. Non-secret fields (host, API base path, default page size) are always written to the home file — `~/.atlassian-dc-mcp/<product>.env` on macOS/Linux, `%USERPROFILE%\.atlassian-dc-mcp\<product>.env` on Windows. After a successful Keychain write, the token line is cleared from the home file so there is never a second copy in a less-secure place.
  39. Once setup has run, the MCP servers can boot with no environment variables at all:
  40. ```json
  41. {
  42. "mcpServers": {
  43. "atlassian-jira-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/jira"] },
  44. "atlassian-confluence-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/confluence"] },
  45. "atlassian-bitbucket-dc": { "command": "npx", "args": ["-y", "@atlassian-dc-mcp/bitbucket"] }
  46. }
  47. }
  48. ```
  49. You can still pass credentials via environment variables or `ATLASSIAN_DC_MCP_CONFIG_FILE` as shown in the sections below — they take precedence over values saved by setup.
  50. ## Configuration Sources & Precedence
  51. At startup, each MCP server resolves each config key by walking sources in this order and taking the first non-empty value:
  52. | Priority | Source | Reads | Written by setup |
  53. |---------:|--------|-------|------------------|
  54. | 100 | `process.env` (`JIRA_*`, `CONFLUENCE_*`, `BITBUCKET_*`) | all keys | — |
  55. | 80 | env file — `ATLASSIAN_DC_MCP_CONFIG_FILE` or `./.env` | all keys | — |
  56. | 60 | home file — `~/.atlassian-dc-mcp/<product>.env` on macOS/Linux, `%USERPROFILE%\.atlassian-dc-mcp\<product>.env` on Windows (mode `0600` on POSIX; Windows inherits the user-profile ACL) | all keys | host, apiBasePath, defaultPageSize (always); token (non-darwin or keychain fallback) |
  57. | 40 | macOS Keychain — service `atlassian-dc-mcp`, account `<product>-token` | token only | token (darwin only) |
  58. Notes:
  59. - Process env wins over everything, so you can always override a stored credential for one session.
  60. - `ATLASSIAN_DC_MCP_CONFIG_FILE` must be an absolute path; if set and missing, the server fails fast.
  61. - Keychain reads are cached at init (one `execFileSync` per product-token), so tool calls never shell out.
  62. - If a higher-priority source shadows the value setup is about to save, setup prints a warning naming the env var so you can unset it.
  63. - Atlassian API requests time out after 30 seconds by default. Set `ATLASSIAN_DC_MCP_REQUEST_TIMEOUT_MS` to a positive millisecond value to override it.
  64. ## Claude Desktop Configuration
  65. [Official Anthropic quick start guide](https://modelcontextprotocol.io/docs/getting-started/intro)
  66. To use these MCP connectors with Claude Desktop, add the following to your Claude Desktop configuration.
  67. Set `*_HOST` variables only to domain + port without protocol (e.g., `your-instance.atlassian.net`). The https protocol is assumed.
  68. Alternatively, you can use `*_API_BASE_PATH` variables instead of `*_HOST` to specify the complete API base URL including protocol (e.g., `https://your-instance.atlassian.net/rest`). Note that the `/api/latest/` part is static and added automatically in the code, so you don't need to include it in the `*_API_BASE_PATH` values.
  69. You can leave only the services you need in the configuration.
  70. macOS:
  71. ```
  72. ~/Library/Application Support/Claude/claude_desktop_config.json
  73. ```
  74. Windows:
  75. ```
  76. %APPDATA%\Claude\claude_desktop_config.json
  77. ```
  78. ```json
  79. {
  80. "mcpServers": {
  81. "atlassian-jira-dc": {
  82. "command": "npx",
  83. "args": ["-y", "@atlassian-dc-mcp/jira"],
  84. "env": {
  85. "JIRA_HOST": "your-jira-host",
  86. "JIRA_API_TOKEN": "your-token"
  87. }
  88. },
  89. "atlassian-confluence-dc": {
  90. "command": "npx",
  91. "args": ["-y", "@atlassian-dc-mcp/confluence"],
  92. "env": {
  93. "CONFLUENCE_HOST": "your-confluence-host",
  94. "CONFLUENCE_API_TOKEN": "your-token"
  95. }
  96. },
  97. "atlassian-bitbucket-dc": {
  98. "command": "npx",
  99. "args": ["-y", "@atlassian-dc-mcp/bitbucket"],
  100. "env": {
  101. "BITBUCKET_HOST": "your-bitbucket-host",
  102. "BITBUCKET_API_TOKEN": "your-token"
  103. }
  104. }
  105. }
  106. }
  107. ```
  108. You can also use the alternative API base path configuration:
  109. ```json
  110. {
  111. "mcpServers": {
  112. "atlassian-jira-dc": {
  113. "command": "npx",
  114. "args": ["-y", "@atlassian-dc-mcp/jira"],
  115. "env": {
  116. "JIRA_API_BASE_PATH": "https://your-jira-host/rest",
  117. "JIRA_API_TOKEN": "your-token"
  118. }
  119. },
  120. "atlassian-confluence-dc": {
  121. "command": "npx",
  122. "args": ["-y", "@atlassian-dc-mcp/confluence"],
  123. "env": {
  124. "CONFLUENCE_API_BASE_PATH": "https://your-confluence-host/rest",
  125. "CONFLUENCE_API_TOKEN": "your-token"
  126. }
  127. },
  128. "atlassian-bitbucket-dc": {
  129. "command": "npx",
  130. "args": ["-y", "@atlassian-dc-mcp/bitbucket"],
  131. "env": {
  132. "BITBUCKET_API_BASE_PATH": "https://your-bitbucket-host/rest",
  133. "BITBUCKET_API_TOKEN": "your-token"
  134. }
  135. }
  136. }
  137. }
  138. ```
  139. ## Shared External Config File
  140. If you want multiple MCP hosts or tools on one machine to reuse the same Atlassian credentials, put the existing `JIRA_*`, `CONFLUENCE_*`, and `BITBUCKET_*` variables into one dotenv-style file and point each MCP server at it with `ATLASSIAN_DC_MCP_CONFIG_FILE`.
  141. The path must be absolute. Direct environment variables still override values from the shared file.
  142. Example shared file:
  143. ```dotenv
  144. JIRA_HOST=your-jira-host
  145. JIRA_API_TOKEN=your-jira-token
  146. JIRA_DEFAULT_PAGE_SIZE=50
  147. CONFLUENCE_HOST=your-confluence-host
  148. CONFLUENCE_API_TOKEN=your-confluence-token
  149. BITBUCKET_HOST=your-bitbucket-host
  150. BITBUCKET_API_TOKEN=your-bitbucket-token
  151. BITBUCKET_DEFAULT_PAGE_SIZE=50
  152. ```
  153. Claude Desktop example using one shared file:
  154. ```json
  155. {
  156. "mcpServers": {
  157. "atlassian-jira-dc": {
  158. "command": "npx",
  159. "args": ["-y", "@atlassian-dc-mcp/jira"],
  160. "env": {
  161. "ATLASSIAN_DC_MCP_CONFIG_FILE": "/Users/your-user/.config/atlassian-dc-mcp.env"
  162. }
  163. },
  164. "atlassian-confluence-dc": {
  165. "command": "npx",
  166. "args": ["-y", "@atlassian-dc-mcp/confluence"],
  167. "env": {
  168. "ATLASSIAN_DC_MCP_CONFIG_FILE": "/Users/your-user/.config/atlassian-dc-mcp.env"
  169. }
  170. },
  171. "atlassian-bitbucket-dc": {
  172. "command": "npx",
  173. "args": ["-y", "@atlassian-dc-mcp/bitbucket"],
  174. "env": {
  175. "ATLASSIAN_DC_MCP_CONFIG_FILE": "/Users/your-user/.config/atlassian-dc-mcp.env"
  176. }
  177. }
  178. }
  179. }
  180. ```
  181. Windows example path:
  182. ```json
  183. {
  184. "mcpServers": {
  185. "atlassian-jira-dc": {
  186. "command": "npx",
  187. "args": ["-y", "@atlassian-dc-mcp/jira"],
  188. "env": {
  189. "ATLASSIAN_DC_MCP_CONFIG_FILE": "C:\\\\Users\\\\your-user\\\\AppData\\\\Roaming\\\\atlassian-dc-mcp.env"
  190. }
  191. }
  192. }
  193. }
  194. ```
  195. ## Claude Code CLI Configuration
  196. To use these MCP connectors with [Claude Code](https://docs.anthropic.com/en/docs/claude-code), add MCP servers using the `claude mcp add` command.
  197. You can add servers at the project scope (stored in `.mcp.json`) or user scope (`-s user`). Adjust the scope and included services to your needs.
  198. ```bash
  199. # Jira
  200. claude mcp add atlassian-jira-dc \
  201. -e JIRA_HOST=your-jira-host \
  202. -e JIRA_API_TOKEN=your-token \
  203. -- npx -y @atlassian-dc-mcp/jira
  204. # Confluence
  205. claude mcp add atlassian-confluence-dc \
  206. -e CONFLUENCE_HOST=your-confluence-host \
  207. -e CONFLUENCE_API_TOKEN=your-token \
  208. -- npx -y @atlassian-dc-mcp/confluence
  209. # Bitbucket
  210. claude mcp add atlassian-bitbucket-dc \
  211. -e BITBUCKET_HOST=your-bitbucket-host \
  212. -e BITBUCKET_API_TOKEN=your-token \
  213. -- npx -y @atlassian-dc-mcp/bitbucket
  214. ```
  215. You can also use `*_API_BASE_PATH` instead of `*_HOST` (same as the Claude Desktop examples above):
  216. ```bash
  217. claude mcp add atlassian-jira-dc \
  218. -e JIRA_API_BASE_PATH=https://your-jira-host/rest \
  219. -e JIRA_API_TOKEN=your-token \
  220. -- npx -y @atlassian-dc-mcp/jira
  221. ```
  222. To add servers at user scope (available across all projects):
  223. ```bash
  224. claude mcp add -s user atlassian-jira-dc \
  225. -e JIRA_HOST=your-jira-host \
  226. -e JIRA_API_TOKEN=your-token \
  227. -- npx -y @atlassian-dc-mcp/jira
  228. ```
  229. To use the shared config file instead of passing credentials inline:
  230. ```bash
  231. claude mcp add atlassian-jira-dc \
  232. -e ATLASSIAN_DC_MCP_CONFIG_FILE=/Users/your-user/.config/atlassian-dc-mcp.env \
  233. -- npx -y @atlassian-dc-mcp/jira
  234. ```
  235. Windows PowerShell example:
  236. ```powershell
  237. claude mcp add atlassian-jira-dc `
  238. -e ATLASSIAN_DC_MCP_CONFIG_FILE=C:\Users\your-user\AppData\Roaming\atlassian-dc-mcp.env `
  239. -- npx -y @atlassian-dc-mcp/jira
  240. ```
  241. ### Generating API Tokens
  242. For Data Center installations, you'll need to generate Personal Access Tokens (PAT) for each service:
  243. #### Jira Data Center
  244. 1. Log in to your Jira instance
  245. 2. Go to Profile > Personal Access Tokens
  246. 3. Click "Create token"
  247. 4. Give it a meaningful name and set appropriate permissions
  248. 5. Copy the generated token immediately (it won't be shown again)
  249. #### Confluence Data Center
  250. 1. Log in to your Confluence instance
  251. 2. Go to Settings > Personal Access Tokens
  252. 3. Click "Create token"
  253. 4. Name your token and set required permissions
  254. 5. Save and copy the token (only shown once)
  255. #### Bitbucket Data Center
  256. 1. Log in to Bitbucket
  257. 2. Go to Manage Account > HTTP access tokens
  258. 3. Click "Create token"
  259. 4. Set a name and permissions
  260. 5. Generate and copy the token immediately
  261. Store these tokens securely and use them in your Claude Desktop configuration as shown above.
  262. ## Overview
  263. The Atlassian DC MCP allows AI assistants to interact with Atlassian products through a standardized interface. It provides tools for:
  264. - **Jira**: Search, view, and create issues
  265. - **Confluence**: Access and manage content
  266. - **Bitbucket**: Interact with repositories and code
  267. ## Prerequisites
  268. - Node.js 18 or higher
  269. - npm 7 or higher (for workspaces support)
  270. - Atlassian Data Center instance or Cloud instance
  271. - API tokens for the Atlassian products you want to use
  272. ## Installation
  273. Clone the repository:
  274. ```bash
  275. git clone https://github.com/b1ff/atlassian-dc-mcp.git
  276. cd atlassian-dc-mcp
  277. ```
  278. ## Development
  279. This project is structured as an npm monorepo using workspaces. The workspaces are organized in the `packages/` directory, with separate packages for each Atlassian product integration.
  280. CI uses Node.js 22 for development tooling. Builds use TypeScript 7 and check
  281. both source files and tests. Jest uses SWC to transform TypeScript tests.
  282. Development and inspector commands use `tsx` to run TypeScript.
  283. Dependency versions are pinned in every `package.json`. The project `.npmrc`
  284. uses `save-exact=true` for future additions.
  285. ### Installing Dependencies
  286. To install all dependencies for all packages in the monorepo:
  287. ```bash
  288. npm install
  289. ```
  290. This will install:
  291. - Root-level dependencies defined in the root `package.json`
  292. - All dependencies for each package in the workspaces
  293. To install a dependency for a specific package:
  294. ```bash
  295. npm install <package-name> --workspace=@atlassian-dc-mcp/jira
  296. ```
  297. To install a dependency at the root level:
  298. ```bash
  299. npm install <package-name> -W
  300. ```
  301. ### Building the Project
  302. To build all packages:
  303. ```bash
  304. npm run build
  305. ```
  306. To build a specific package:
  307. ```bash
  308. npm run build --workspace=@atlassian-dc-mcp/jira
  309. ```
  310. ### Running in Development Mode
  311. To run a specific package in development mode:
  312. ```bash
  313. npm run dev:jira # For Jira
  314. npm run dev:confluence # For Confluence
  315. npm run dev:bitbucket # For Bitbucket
  316. ```
  317. ## Configuration
  318. For production use, prefer the [Quick Setup](#quick-setup) CLI above — it writes to the macOS Keychain (for tokens) and the home file for non-secret fields (`~/.atlassian-dc-mcp/<product>.env` on macOS/Linux, `%USERPROFILE%\.atlassian-dc-mcp\<product>.env` on Windows) automatically.
  319. For local development, create a `.env` file in the root directory, or a shared dotenv-style file anywhere on disk and point `ATLASSIAN_DC_MCP_CONFIG_FILE` to it, with the following variables:
  320. ```
  321. # Jira configuration - choose one of these options:
  322. JIRA_HOST=your-instance.atlassian.net
  323. # OR
  324. JIRA_API_BASE_PATH=https://your-instance.atlassian.net/rest
  325. # Note: part /api/2/search/ is added automatically, do not include it
  326. JIRA_API_TOKEN=your-api-token
  327. # Confluence configuration - choose one of these options:
  328. CONFLUENCE_HOST=your-instance.atlassian.net
  329. # OR
  330. CONFLUENCE_API_BASE_PATH=https://your-instance.atlassian.net/confluence
  331. # Note: part /rest/api is added automatically, do not include it
  332. CONFLUENCE_API_TOKEN=your-api-token
  333. # Bitbucket configuration - choose one of these options:
  334. BITBUCKET_HOST=your-instance.atlassian.net
  335. # OR
  336. BITBUCKET_API_BASE_PATH=https://your-instance.atlassian.net/rest
  337. # Note: part /api/latest/ is added automatically, do not include it
  338. BITBUCKET_API_TOKEN=your-api-token
  339. ```
  340. Resolution order for each key is `process.env` → `ATLASSIAN_DC_MCP_CONFIG_FILE` (or `./.env`) → home file (`~/.atlassian-dc-mcp/<product>.env` on macOS/Linux, `%USERPROFILE%\.atlassian-dc-mcp\<product>.env` on Windows) → macOS Keychain. See [Configuration Sources & Precedence](#configuration-sources--precedence) above.
  341. ## License
  342. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

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