Skip to content
Back to search

ChannelTerm

Shared terminal sessions for humans and AI agents, starting with serial and hardware debugging.

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/akira-init1--channelterm/badge.svg)](/listings/akira-init1--channelterm)

HTML

<a href="/listings/akira-init1--channelterm"><img src="/api/listings/akira-init1--channelterm/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.

List native serial targets without requiring a running MCP server:

channelterm list --kind device --transport serial --no-mcp

Skip this discovery step when the native target, such as `COM50`, is already known.

If an AI client should join the Session, configure a supported client once before attaching:

channelterm init --mcp

Choose HTTP, or press Enter for the HTTP default. The configuration includes the local Bearer credential. Reload the AI client if it does not pick up configuration changes immediately.

Then run the command for the current platform:

# Windows
channelterm attach COM8 --baud 115200 --label board

# Linux
channelterm attach /dev/ttyUSB0 --baud 115200 --label board

# macOS
channelterm attach /dev/cu.usbserial-110 --baud 115200 --label board

That single `attach` command opens the serial device and attaches the current terminal. When no compatible Host is already running at the default endpoint, it also starts a temporary local HTTP MCP Session Host automatically. Typical startup output is:

Shared Session created: SER-1 (0123456789abcdef0123456789abcdef)
[ChannelTerm] Temporary Session Host started; it and all shared Sessions stop when this attachment exits. Run 'channelterm mcp --transport http' separately for a persistent Host.

No separate MCP-server terminal is required for this quick path. While the attachment remains open, a configured HTTP MCP client can use `http://127.0.0.1:37099/mcp` and operate the same `SER-1`. The temporary Host and every Session it owns stop when the creating attachment exits; use a persistent Host only when Sessions must outlive that terminal.

`--label board` is an optional display name, not an identifier. Use `SER-1` or the opaque Session ID when another client needs to refer to the Session.

Common workflows

| Goal | Command | | --- | --- | | Open a shared serial Session and auto-start a temporary Host | `channelterm attach COM8 --baud 115200` | | Configure a supported AI client for the shared HTTP Host | `channelterm init --mcp` | | Keep the Host and Sessions alive independently | `channelterm mcp --transport http` | | List or join an existing Session | `channelterm list --kind session` then `channelterm attach SER-1` | | Open a private serial connection with no MCP sharing | `channelterm attach COM8 --private --baud 115200` | | Watch structured Session activity | `channelterm events SER-1` | | Open the guided file-transfer menu in the current shared attachment | Press `Ctrl+]`, then press `f` | | Send or receive through a shared Session | `channelterm file send firmware.bin --session SER-1` or `channelterm file receive /tmp/log.txt ./log.txt --session SER-1` |

A persistent Host is a separate long-running process. After it reports `MCP Streamable HTTP listening on http://127.0.0.1:37099/mcp`, other shells and configured AI clients can create or join Sessions. Silence after the readiness line is normal; stop the Host with `Ctrl+C` when all of its Sessions should close.

While attached:

Ctrl+C      Send 0x03 to the remote terminal
Ctrl+] q    Leave this CLI; an attachment-owned temporary Host also stops
Ctrl+] ?    Show local escape help
Ctrl+] ]    Send a literal Ctrl+] byte
Ctrl+] t    Toggle local shell-prompt timestamps
Ctrl+] f    Open the local file send/receive menu
Ctrl+] Esc  Cancel local escape mode

To add a supported AI client to the same Host, run `channelterm init --mcp`, select HTTP, and let the client list or operate `SER-1`. See [MCP Server](docs/getting-started/mcp-server.md) for the authentication and client workflow.

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 · 388 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. [English](README.md) | [Deutsch](README.de.md) | [Español](README.es.md) | [Français](README.fr.md) | [日本語](README.ja.md) | [한국어](README.ko.md) | [Русский](README.ru.md) | [简体中文](README.zh-CN.md) | [繁體中文](README.zh-TW.md)
  2. # ChannelTerm
  3. **Debug your board with AI. Stay in the same terminal.**
  4. ChannelTerm lets you and your AI client share a live serial or SSH terminal. Read the same device output, follow AI terminal commands, and take turns operating the board. It runs on Windows, Linux, and macOS and connects external AI clients through MCP.
  5. Use GDB to let AI set breakpoints, step through Linux programs, and inspect variables. Connect the serial port on Windows and run GDB in WSL2, or keep the shared console open while GDB uses the board's Ethernet connection. [Choose a debugging setup](#gdb-debugging).
  6. For short boot windows, let the Host interrupt U-Boot and verify the prompt. Export a diagnostic ZIP with optional raw bytes when investigating failures. [U-Boot and diagnostic workflow](docs/getting-started/serial-terminal.md#enter-u-boot-and-export-evidence).
  7. ## Why ChannelTerm?
  8. Keep your terminal open while the AI works with the same device connection:
  9. ```text
  10. +---- Human terminal
  11. |
  12. Serial device ---- Session
  13. |
  14. +---- AI / MCP client
  15. ```
  16. Each client reads independently, so an AI reader does not consume the output you are watching. ChannelTerm displays AI terminal writes in your attachment; external debugger output has its own [visibility rules](#gdb-debugging).
  17. ## What It Enables
  18. - **Share the console:** human CLI and AI/MCP clients use one serial or SSH Session.
  19. - **Follow the work:** see AI terminal commands alongside the device's output.
  20. - **Debug Linux programs:** use managed GDB, a serial bridge, or GDB over the network.
  21. - **Move files:** transfer over a shared serial Session with SHA-256 checks, or use dedicated SFTP/SCP connections.
  22. - **Start with one attachment:** `channelterm attach` can create the local shared Host automatically.
  23. ## Installation
  24. Download the archive for your operating system and architecture from
  25. [Releases](https://github.com/akira-init1/ChannelTerm/releases) and verify it against that release's
  26. `SHA256SUMS`. Extract it, then run `.\channelterm.exe install` on Windows or `./channelterm install`
  27. on Linux/macOS from the extracted directory. Prebuilt binaries do not require Go.
  28. Building from source requires Go 1.26 or newer. Use a currently supported patched Go toolchain,
  29. then build the native executable from the repository root:
  30. ```bash
  31. git clone https://github.com/akira-init1/ChannelTerm.git
  32. cd ChannelTerm
  33. go build ./cmd/channelterm
  34. ./channelterm install
  35. ```
  36. `install` copies the running binary into the current user's standard program location, creates the
  37. `channelterm` and `cterm` commands, adds that location to the user PATH only when necessary, and
  38. initializes a missing minimal configuration. Open a new terminal when it reports a PATH change.
  39. `channelterm uninstall` removes the installer-owned commands and PATH change while preserving user
  40. data; `channelterm uninstall --purge` requires explicit confirmation before deleting configuration,
  41. device state, and the local HTTP credential.
  42. Supported desktop targets are Windows, Linux, and macOS on amd64/arm64. See [Build and install from source](docs/getting-started/build.md), the exact
  43. [`install` / `uninstall` contract](docs/reference/cli.md#install-and-uninstall), and
  44. [configuration locations](docs/reference/configuration.md). Repository checks and cross-build
  45. scripts are covered by [Building and testing](docs/development/building-and-testing.md).
  46. ## Quick Start: One Command, One Terminal
  47. List detected serial devices, saved profiles, and Sessions from the default HTTP Host when it is
  48. available:
  49. ```bash
  50. channelterm list
  51. ```
  52. A running Host is optional. When it is unavailable, `list` reports MCP as offline and still shows
  53. local devices and profiles.
  54. See the [CLI reference](docs/reference/cli.md#list) for the complete option contract.
  55. If an AI client should join the Session, configure a supported client once before attaching:
  56. ```bash
  57. channelterm init --mcp
  58. ```
  59. Choose HTTP, or press Enter for the HTTP default. The configuration includes the local Bearer
  60. credential. Reload the AI client if it does not pick up configuration changes immediately.
  61. Then run the command for the current platform:
  62. ```bash
  63. # Windows
  64. channelterm attach COM8 --baud 115200 --label board
  65. # Linux
  66. channelterm attach /dev/ttyUSB0 --baud 115200 --label board
  67. # macOS
  68. channelterm attach /dev/cu.usbserial-110 --baud 115200 --label board
  69. ```
  70. That single `attach` command opens the serial device and attaches the current terminal. When no
  71. compatible Host is already running at the default endpoint, it also starts a temporary local HTTP
  72. MCP Session Host automatically. Typical startup output is:
  73. ```text
  74. Shared Session created: SER-1 (0123456789abcdef0123456789abcdef)
  75. [ChannelTerm] Temporary Session Host started; it and all shared Sessions stop when this attachment exits. Run 'channelterm mcp --transport http' separately for a persistent Host.
  76. ```
  77. No separate MCP-server terminal is required for this quick path. While the attachment remains open,
  78. a configured HTTP MCP client can use `http://127.0.0.1:37099/mcp` and operate the same `SER-1`.
  79. The temporary Host and every Session it owns stop when the creating attachment exits; use a
  80. persistent Host only when Sessions must outlive that terminal.
  81. `--label board` is an optional display name, not an identifier. Use `SER-1` or the opaque Session ID
  82. when another client needs to refer to the Session.
  83. ### Common workflows
  84. | Goal | Command |
  85. | --- | --- |
  86. | Open a shared serial Session and auto-start a temporary Host | `channelterm attach COM8 --baud 115200` |
  87. | Configure a supported AI client for the shared HTTP Host | `channelterm init --mcp` |
  88. | Keep the Host and Sessions alive independently | `channelterm mcp --transport http` |
  89. | List or join an existing Session | `channelterm list --kind session` then `channelterm attach SER-1` |
  90. | Open a private serial connection with no MCP sharing | `channelterm attach COM8 --private --baud 115200` |
  91. | Watch structured Session activity | `channelterm events SER-1` |
  92. | Open the guided file-transfer menu in the current shared attachment | Press `Ctrl+]`, then press `f` |
  93. | Send or receive through a shared Session | `channelterm file send firmware.bin --session SER-1` or `channelterm file receive /tmp/log.txt ./log.txt --session SER-1` |
  94. A persistent Host is a separate long-running process. After it reports
  95. `MCP Streamable HTTP listening on http://127.0.0.1:37099/mcp`, other shells and configured AI clients
  96. can create or join Sessions. Silence after the readiness line is normal; stop the Host with
  97. `Ctrl+C` when all of its Sessions should close.
  98. During ordinary terminal use, outside a file transfer or debugger takeover:
  99. ```text
  100. Ctrl+C Send 0x03 to the remote terminal
  101. Ctrl+] q Leave this CLI; an attachment-owned temporary Host also stops
  102. Ctrl+] ? Show local escape help
  103. ```
  104. See the [CLI reference](docs/reference/cli.md#attach) for all local controls and the [MCP workflow](docs/getting-started/mcp-server.md) for client setup and AI-created Sessions.
  105. For reusable workflow guidance, install the bundled
  106. [`cterm-serial-debug` Agent Skill](docs/getting-started/mcp-server.md#install-the-bundled-agent-skill)
  107. in an Agent Skills-compatible client. `channelterm init --mcp` configures MCP clients but does not
  108. install the Skill.
  109. The HTTP server requires a per-user Bearer token and defaults to a loopback-only listener. Built-in
  110. CLI clients use the local token automatically. It can also [listen on a trusted
  111. LAN](docs/getting-started/mcp-server.md#listen-on-a-lan); remote clients must use the Host's reachable
  112. address and send the same token through the `Authorization` header. Do not expose the endpoint
  113. without TLS and separate network access controls.
  114. <a id="example-workflows"></a>
  115. <a id="embedded-linux-debugging"></a>
  116. <a id="ai-operates-human-observes"></a>
  117. <a id="human-intervenes"></a>
  118. ## A Shared Terminal in Practice
  119. An attached CLI renders an Agent command as a local `AI` activity block. `terminal_exec` keeps that
  120. command out of an idle Bash prompt's history; the lines after the block are still the device's raw
  121. terminal output, and the human can type again when the short command lease is released:
  122. ```bash
  123. root@board:~#
  124. ──────── AI ────────
  125. [18:52:31] >> echo agent-check
  126. ────────────────────
  127. agent-check
  128. root@board:~# echo human-still-here
  129. human-still-here
  130. root@board:~#
  131. ```
  132. The exact command output depends on the connected device. The `AI` block is local presentation
  133. derived from structured Session events; it is not inserted into the device byte stream or stored
  134. terminal output. Raw keys and interactive programs still use `terminal_write` and retain the
  135. device's normal history behavior.
  136. ## Shared SSH shell
  137. Connect using an authorized private key (encrypted keys prompt for a passphrase) or enter your
  138. login password when prompted. Passwords and key passphrases are not saved. For an unknown server,
  139. verify its displayed fingerprint and enter `yes` to save its public
  140. key in `~/.ssh/known_hosts`; changed keys are rejected. Prompts require an interactive terminal:
  141. ```bash
  142. # Terminal 1: open the shell; then run uname -a at its prompt.
  143. channelterm ssh user@192.168.1.50
  144. # Terminal 2: observe and use the same shell.
  145. channelterm attach SSH-1
  146. ```
  147. Keep the first command running: exiting it closes this Host and its Sessions. The default local sharing port must be free; use `--listen` and the printed attach endpoint for a separate Host. See the [SSH workflow](docs/getting-started/ssh-terminal.md) for key paths, host verification, ports, and current limits.
  148. ## Files over SSH
  149. Use SFTP for file transfer and remote file management, or legacy SCP for compatible POSIX servers:
  150. ```bash
  151. channelterm sftp user@192.168.1.50 ls /tmp
  152. channelterm sftp user@192.168.1.50 put ./firmware.bin /tmp/firmware.bin
  153. channelterm sftp user@192.168.1.50 get /tmp/log.txt ./log.txt
  154. channelterm scp user@192.168.1.50 put ./release /tmp/release --recursive
  155. ```
  156. These commands use the same key/password authentication and host verification as SSH, with a
  157. dedicated connection independent of terminal Sessions. Replacing existing files requires
  158. `--overwrite`. See [file transfer](docs/getting-started/file-transfer.md#sftp-and-scp-over-ssh)
  159. for directory semantics, cancellation, and protocol limits.
  160. Transfers over shared terminal Sessions use a small Linux-shell protocol. Dedicated SSH file
  161. connections use SFTP or legacy SCP.
  162. <a id="ai-files-and-local-controls"></a>
  163. ## Files over a shared Session
  164. That shared serial Session can also transfer regular files and directories without an AI client or a separately installed board-side transfer agent. In an active shared `attach`, press `Ctrl+]` and then `f` to open the guided send/receive menu. Directories use standard tar and acknowledged, cancellation-friendly chunks; the same operations are available as commands:
  165. ```bash
  166. channelterm file send firmware.bin --session SER-1
  167. channelterm file receive /tmp/log.txt ./log.txt --session SER-1
  168. channelterm file send ./build/release /tmp/release --session SER-1
  169. channelterm file receive /var/log/myapp ./myapp --session SER-1
  170. ```
  171. Transfers require an idle Linux shell with the utilities listed in the [file-transfer workflow](docs/getting-started/file-transfer.md). They verify SHA-256 and select a new name instead of overwriting an existing destination. During a transfer, `Ctrl+C` in a shared attachment asks for cancellation; other writers remain blocked until cleanup releases the lease.
  172. <a id="gdb-debugging"></a>
  173. ## Remote debugging with GDB
  174. Choose how the debugger reaches your Linux program. Each path needs tools and symbols compatible with the target.
  175. | Path | GDB connection | Console / Session during debugging |
  176. | --- | --- | --- |
  177. | [Serial bridge](#gdb-serial-bridge) | Workstation GDB → ChannelTerm → board serial port; Windows + WSL2 example below | Reserved for GDB until restored |
  178. | [Serial console + TCP](#gdb-serial-tcp) | Workstation GDB → board network interface; WSL2, Linux, Windows, or macOS with compatible GDB | Available for independent shell/log work |
  179. | [Managed GDB/MI](docs/getting-started/gdb-debugging.md#managed-native-linux-prerequisites) | MCP tools control GDB; Host, shell, tools, and ELF must share one native Linux environment | The selected Session is reserved during debugging |
  180. <a id="gdb-serial-bridge"></a>
  181. ### Serial GDB bridge: Windows + WSL2
  182. **Windows connects the serial port; WSL2 runs GDB; the AI coordinates remote debugging.** The Windows ChannelTerm Host keeps the COM port and shared Session open. A target-compatible GDB in WSL2 connects through the Linux `channelterm rsp-client` helper and the authenticated TLS/TCP bridge to the board's Linux gdbserver.
  183. ```mermaid
  184. flowchart LR
  185. AI["AI client"]
  186. Human["Human terminal"]
  187. subgraph Windows
  188. Host["ChannelTerm Host"]
  189. COM["COM port"]
  190. Host <--> COM
  191. end
  192. subgraph WSL2["WSL2 / Linux"]
  193. GDB["Target-compatible GDB"]
  194. Helper["Linux channelterm rsp-client"]
  195. GDB <--> Helper
  196. end
  197. Board["Linux board / gdbserver"]
  198. AI -->|"MCP: prepare and manage"| Host
  199. AI -->|"Process tool: GDB commands"| GDB
  200. Human ---|"attach / AI reports"| Host
  201. Helper <-->|"TLS/TCP"| Host
  202. COM <-->|"Serial RSP"| Board
  203. ```
  204. Keep your Windows serial driver and Linux toolchain: the serial device stays on Windows, and the board needs no network GDB port.
  205. 1. On Windows, configure the AI client with `channelterm init --mcp` (HTTP), then open the board, for example `channelterm attach COM8 --baud 115200`. Use the board's confirmed serial settings and keep the owning Host running.
  206. 2. Following the [bridge preparation steps](docs/getting-started/gdb-debugging.md#prepare-and-open), save the TTY state, prepare a compatible `gdbserver --once stdio` on the board, and call `debug_bridge_start` through MCP. The AI also needs a process execution tool to run GDB in WSL2.
  207. 3. In WSL2, use Linux ChannelTerm and target-compatible GDB with the matching ELF. Save the private connection descriptor as `bridge.json` in WSL's filesystem (`chmod 600`). The [WSL2 guide](docs/getting-started/gdb-debugging.md#connect-independent-gdb-from-wsl2) covers networking and paths. Replace the descriptor path below:
  208. ```text
  209. (gdb) target remote | channelterm rsp-client --connection /home/EXAMPLE/private/bridge.json
  210. (gdb) break main
  211. (gdb) continue
  212. (gdb) next
  213. (gdb) backtrace
  214. (gdb) detach
  215. ```
  216. 4. On Windows, use `channelterm gdb-list` or `channelterm gdb-list --json` to see bridge ports and states. After GDB detach, confirm the board has returned to its shell and call `debug_bridge_restore` with the saved TTY state to resume shared terminal use.
  217. For this serial bridge, AI can publish actual commands and observations through `debug_bridge_report` so you can follow them in the attached terminal. Entries are labelled AI reports, not a complete automatic GDB transcript.
  218. <a id="gdb-serial-tcp"></a>
  219. ### Shared serial console + GDB over Ethernet
  220. Keep the serial console available for shared logs and shell work while GDB uses the network. The serial Host and GDB can be on the same computer or different computers; choose each environment's serial driver and target toolchain independently.
  221. ```mermaid
  222. flowchart LR
  223. AI["AI client"]
  224. Human["Human terminal"]
  225. Host["ChannelTerm Host"]
  226. GDB["Workstation GDB: WSL2 / Linux / Windows / macOS"]
  227. subgraph Board["Linux board"]
  228. Console["Serial shell / logs"]
  229. Server["gdbserver"]
  230. end
  231. Human ---|"attach"| Host
  232. AI -->|"MCP"| Host
  233. AI -->|"Process tool: GDB commands"| GDB
  234. Host <-->|"Serial"| Console
  235. GDB <-->|"TCP / Ethernet"| Server
  236. ```
  237. Keep gdbserver running independently of the interactive serial shell if you want to continue issuing shell commands. Load the matching ELF in workstation GDB, then connect over a restricted network as below (replace `TARGET_IP` and the port). See the [serial-console + TCP workflow](docs/getting-started/gdb-debugging.md#shared-serial-console-with-tcp-gdb) for target startup, application I/O, and SSH tunnelling.
  238. ```text
  239. (gdb) target remote TARGET_IP:2345
  240. ```
  241. This TCP path uses gdbserver directly, without `rsp-client` or `debug_bridge_*`. Human and AI see the shared serial activity; external GDB commands/results remain in the debugger's own output and are not automatically mirrored into the serial attachment.
  242. Managed GDB/MI and the external bridge have real GDB/gdbserver coverage on Linux PTYs in CI. See the [full workflow](docs/getting-started/gdb-debugging.md) for setup, compatibility, SSH alternatives, and recovery.
  243. ## How It Works
  244. ```text
  245. Human CLI -----+
  246. +--> Session Host --> Session <--> Channel <--> Serial / SSH endpoint
  247. AI via MCP ----+ |
  248. +-- retained output, activity, events
  249. `-- serialized writes
  250. ```
  251. The Session Host owns connections and Session lifetimes. A Serial or SSH Transport establishes a protocol-neutral Channel; Session reads that Channel, retains bounded output, activity, and events in memory, and serializes writes. CLI and MCP adapters reuse the same Core behavior. Presentation such as highlighting and the `AI` activity block stays outside stored terminal data.
  252. Readers have independent cursors. Raw writes are serialized but do not coordinate shell commands; application leases temporarily block other writers during command execution, transfers, and debugging. See [shared Sessions](docs/getting-started/shared-session.md) for ownership and concurrency.
  253. Shared references such as `SER-1` are valid only within the owning Host process. Stopping that Host closes its Sessions. A secondary attachment can leave independently. Exiting the attachment that owns a temporary Host, or the SSH command that created its Host, also closes that Host and its Sessions. See the [architecture overview](docs/architecture/overview.md) for the layer boundaries.
  254. ## Configuration
  255. `config.toml` contains user-owned serial profiles and connection policy. `state.json` is
  256. ChannelTerm-managed device identity state. `http-auth-token` is the secret used to authenticate MCP
  257. HTTP clients; do not share or commit it.
  258. ```powershell
  259. # Save and reuse a serial profile.
  260. channelterm serial --port COM8 --baud 115200 --save board
  261. channelterm serial --profile board
  262. # Select a different config.toml for this operation.
  263. channelterm serial --config ./channelterm.toml --profile board
  264. ```
  265. Common options are `--profile`, `--save`, `--config`, `--port`, and `--baud`; the MCP Host also
  266. accepts `--connection-policy ask|auto|deny`. `--config` changes only the selected `config.toml`, not
  267. the default `state.json` or `http-auth-token`. See [Serial profiles](docs/getting-started/serial-profiles.md)
  268. and the [configuration reference](docs/reference/configuration.md) for complete fields, precedence,
  269. validation, and persistence behavior.
  270. ## Documentation
  271. - [Documentation index](docs/README.md)
  272. - [Serial terminal workflow](docs/getting-started/serial-terminal.md)
  273. - [SSH shell workflow](docs/getting-started/ssh-terminal.md)
  274. - [Shared Session workflow](docs/getting-started/shared-session.md)
  275. - [File-transfer workflow](docs/getting-started/file-transfer.md)
  276. - [MCP server workflow](docs/getting-started/mcp-server.md)
  277. - [GDB debugging workflow](docs/getting-started/gdb-debugging.md)
  278. - [CLI reference](docs/reference/cli.md)
  279. - [MCP tool reference](docs/reference/mcp-tools.md)
  280. - [Identifiers and references](docs/reference/identifiers.md)
  281. - [Architecture overview](docs/architecture/overview.md)
  282. For exact command flags and defaults, the running program's `--help` output is authoritative.
  283. ## Roadmap
  284. Serial and SSH PTY shells are implemented Transports; dedicated SFTP and legacy SCP file clients are also available. Arbitrary SSH exec, Telnet, and stronger multi-writer coordination remain future directions rather than implemented features or release commitments.
  285. ChannelTerm does not currently implement JTAG/OpenOCD, virtual serial devices, a built-in AI, or multi-agent orchestration.
  286. ## License
  287. ChannelTerm is licensed under the [Apache License 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

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