# Termalin — full reference

> Termalin is a cross-platform SSH/terminal client for developers and their AI agents. Tabbed terminal, SFTP/FTP/S3 file browsers with a built-in editor, a database client for 13 engines (PostgreSQL, MySQL/MariaDB, SQLite, SQL Server, MongoDB, Redis, ClickHouse, Elasticsearch, Cassandra, Neo4j, InfluxDB, RabbitMQ, Cloudflare D1), SSH key & agent management, port forwarding, end-to-end encrypted cloud sync, session recording & replay, and a built-in MCP server so agents can reach the same hosts and databases — keys never touch disk. Servers and databases behind a firewall are reachable keylessly through the Termalin Connector (one-line install, no inbound port). Desktop apps for Windows, macOS and Linux; native apps for iPhone, iPad and Apple Watch; a full browser cabinet at https://termal.in/account (Android and anything else).

Key links: Docs https://termal.in/docs/ · MCP server https://termal.in/mcp/ · Server monitoring https://termal.in/server-monitoring/ · Pricing https://termal.in/pricing/ · Security https://termal.in/security/ · Download https://termal.in/download/ · Changelog https://termal.in/changelog/

Positioning: agent-native SSH. The hosted MCP server exposes SSH, SFTP, background-job, database and monitoring tools to AI agents; private hosts are reachable through a keyless tunnel agent (short-lived SSH certificate, no key handed out); every agent action is marked in the session recording and the audit log. The vault (hosts, keys, snippets, recordings) is encrypted on the device with a key derived from the master password before syncing — the server only ever stores ciphertext.

---

# MCP server for SSH

MCP (Model Context Protocol) is the open standard for connecting AI agents to tools. Termalin's MCP server wraps *your servers*, so an agent can operate real infrastructure — tail a log, restart a service, check disk, edit a config, deploy — authenticating through Termalin's SSH key agent so no private key is written to disk or handed to the model.

## Tools — 22 on the local server, 24 on the hosted surfaces
Full reference with arguments: https://termal.in/docs/mcp-tools/

The 24 hosted tools (the OAuth connector at /mcp and the API-key endpoint at /api/v1/mcp expose the same set):
- hosts_list — list the hosts the agent may reach
- ssh_exec — run a command on a host, return output + exit code
- ssh_exec_many — run one command on several servers at once
- job_start / job_status / job_stop / job_list — run a long command in the background, read its log and exit code, stop it
- server_metrics — latest CPU, memory, disk, load and network numbers for every server, or one server's detail with averages and peaks over the last hours; read from Termalin's monitoring, nothing is run on the server
- alerts_list — what monitoring says is wrong right now (disk filling, memory or load pinned, a failed service, an expiring certificate, a server offline) and what cleared in the last seven days
- updates_list — what is waiting to be installed, from the hourly check (nothing is installed): update and security-update counts, the security packages by name, a reboot asked for, a newer kernel waiting for one; plus the known vulnerabilities (CVEs) in the installed software, matched daily (OSV.dev, CISA KEV, FIRST EPSS, Node.js advisories, endoflife.date, Microsoft/MSRC, and the CVE List for a high/critical CVE in its first hour), with the fixed version and how to fix each (update command, reboot/restart, fix in testing, the update to run in a lock file's folder, or the vendor's workaround — Ubuntu, Red Hat — when there is no fix yet) and EPSS; covers Linux, Windows, macOS, running containers, application lock files and about eighty programs and web apps no distribution ships; one server, a tag, all, or only the servers with a given CVE
- backup_create — take an encrypted backup of a server now, before a risky change (label says why); needs a backup job set up in the cabinet; full-access callers only
- backup_list — a server's backup jobs and recent archives: when, whether they worked, size, where stored
- backup_job_create — draft a backup job (files and/or databases, schedule, how many to keep, where to store) for the owner to confirm in the cabinet; it runs only after they confirm, and the encryption key is made in their browser; a draft expires after 7 days and counts toward plan limits; needs full access on the Connector
- web_link_create / web_link_list / web_link_update / web_link_delete — add a web service only the server's network reaches (e.g. localhost:3000, 10.0.0.5:8080) to the owner's cabinet as an internal site, list them, change one, remove one; one site opens every page of an app: web_link_create returns the existing site for the same host:port (reused: true) instead of adding a copy, and its open_url lands on the path given (e.g. localhost:3000/reports/q3.pdf); web_link_update renames a site or points it at another host:port or start page, keeping its address and the people it was shared with (when it now leads elsewhere, everyone signed in to it is signed out and opens it again); only the owner opens it, signed in; sharing stays with the owner in the cabinet; adding, changing and removing need full access on a Connector open to AI
- sftp_list — list a directory over SFTP
- sftp_read — read a text file over SFTP (capped, text-only)
- sftp_write — write a text file over SFTP
- data_tables / data_schema / data_query — explore and query connected databases (read-only by default, per-connection agent policy)
- generate_password — generate a strong random password

## Local server (termalin-mcp) — 22 tools
Shares hosts_list, generate_password, ssh_exec, sftp_list and data_tables / data_schema / data_query with the hosted set (files use sftp_get / sftp_put in place of sftp_read / sftp_write); ssh_exec_many, the job_* tools, server_metrics and alerts_list are hosted only. Local only:
- session_open / session_exec / session_close / session_list — persistent SSH sessions
- tunnel_open / tunnel_close / tunnel_list — open, close and list port forwards
- data_list — list the app's saved database connections
- terminal_open / terminal_run / terminal_run_many / terminal_sessions / terminal_hosts — drive the running desktop app: open live tabs, or step into a session you already have open (consent-gated)

## Connect — claude.ai / ChatGPT (chat connector, no install)
Prerequisite: the chat reaches servers running a Connector only. Install one first: sign in at https://termal.in/account, click Add Connector, copy the one-line install command, run it on the server. A host that only exists in the desktop app is NOT reachable and stays invisible to the connector (the chat will answer "no servers"). A Connector dials out (no inbound port, no SSH key on your device; short-lived SSH certificate); Linux (x86_64 and aarch64; a termalin-agent.service systemd unit, or `termalin-agent run` without systemd), macOS (same install line, `curl -fsSL https://termal.in/i/<token> | sudo sh`; launchd daemon) and Windows x64 or ARM64 (`irm https://termal.in/i/<token>.ps1 | iex` in PowerShell, which asks for administrator rights itself; Windows service). Per-Connector settings: Name, Login user (AI apps use root if empty), AI access switch, Note for AI. Connectors are Pro; Free has none.
claude.ai: open the Termalin listing in the connectors directory (https://claude.ai/directory/termalin) and click Connect, or add it by URL under Settings -> Connectors -> Add custom connector -> https://termal.in/mcp
ChatGPT: open Termalin in the ChatGPT apps directory and connect, or add it by URL under Settings -> Connectors (section naming varies by version; the developer-mode toggle may be required) -> same URL
Claude Code, Codex, Cursor and other OAuth-capable MCP clients: add https://termal.in/mcp as a remote (HTTP) MCP server and sign in when asked. Exact commands:
    Claude Code: claude mcp add --transport http termalin https://termal.in/mcp
    Codex:       codex mcp add termalin --url https://termal.in/mcp
    Cursor mcp.json: { "mcpServers": { "termalin": { "url": "https://termal.in/mcp" } } }
Gemini (gemini.google.com): Settings -> Connected Apps -> Custom apps -> Add a custom app -> same URL -> Next (for now US only, 18+, personal Google accounts, English; then works in the Gemini mobile app too)
Grok: grok.com/connectors -> New Connector -> Custom -> same URL (grok.com, Grok mobile apps, Grok CLI)
Mistral Le Chat: chat.mistral.ai/connections -> Add Connector -> Custom MCP Connector -> name + same URL -> sign in (needs a workspace admin; every plan including Free)
Perplexity: Settings -> Connectors -> + Custom connector -> Remote -> name + same URL -> sign in (Pro, Max and Enterprise)
Meta Muse: add a custom connector with the same URL -> sign in (a listing in the Muse connector directory is under review)
Manus: Connectors -> Create -> add an MCP server by URL -> same URL -> sign in
OpenClaw: openclaw mcp add termalin --url https://termal.in/mcp, then openclaw mcp login termalin; or openclaw plugins install https://github.com/termalinapp/termalin-plugin (listed on ClawHub: https://clawhub.ai/wolfhound1995/termalin)
Hermes Agent (Nous Research): ~/.hermes/config.yaml -> mcp_servers: -> termalin: with url: "https://termal.in/mcp" and auth: oauth (browser sign-in on first connection; catalog entry "hermes mcp install termalin" pending review)
OpenCode: opencode.jsonc -> { "mcp": { "servers": { "termalin": { "type": "remote", "url": "https://termal.in/mcp" } } } } (OAuth on first use, or opencode mcp auth termalin)
Kilo Code / Kilo CLI: add a remote MCP server with the same URL in the MCP settings (Kilo Marketplace entry pending review)
Listed in: Claude connector directory (https://claude.ai/directory/termalin), ChatGPT app directory (search Termalin under Apps), Official MCP Registry (in.termal/termalin-web), Glama (https://glama.ai/mcp/connectors/in.termal/termalin-web), Smithery, mcpservers.org (https://mcpservers.org/servers/termal-in-mcp), MCP Server Spot (https://www.mcpserverspot.com/servers/termalin), ClawHub (https://clawhub.ai/wolfhound1995/termalin), mcptry, Toolradar; more catalogs in review
Plugin repository (MIT): https://github.com/termalinapp/termalin-plugin — one manifest per plugin format, all pointing at https://termal.in/mcp, with five skills (server-health, incident-triage, run-commands, deploy-check, database-access). Install:
    Claude Code: /plugin marketplace add termalinapp/termalin-plugin, then /plugin install termalin@termalin
    Gemini CLI:  gemini extensions install https://github.com/termalinapp/termalin-plugin
    Antigravity: agy plugin install https://github.com/termalinapp/termalin-plugin
    Kiro:        Powers -> Add Custom Power -> Import power from GitHub -> repository URL -> Install
    Cursor:      loads the repository (Agent Plugins standard: plugin.json + mcp.json at the root); marketplace listing pending, until then the mcp.json entry above
    Grok Build:  once listed, /marketplace inside Grok Build, or grok plugin install termalin --trust
Then enable Termalin in the conversation itself via the composer's tools/plus menu — adding the connector in settings is not always enough for the model to call its tools.
The chat discovers the server, opens Termalin's sign-in page, and after one approval can list servers, run commands and read/write files in the conversation. Auth is OAuth 2.1 (dynamic client registration + PKCE); tokens are scoped to the user's own enrolled servers and revocable.
Each connected AI app (and each API key) carries its own command rule: Full access / Only listed commands / Read-only — no commands or file writes. Each Connector can add its own rule on top ("What AI may run here": full access / only listed commands / read-only); the stricter of the two applies, and hosts_list reports it per server as policy. A server is reachable only while its Connector's AI access switch is on, and its "Note for AI" rides along as ownerNote in hosts_list. The hosted path is Pro (or the trial): on Free the chat app is told the trial ended and handed the upgrade link.

## Connect — local server (runs on your machine)
    claude mcp add termalin -- <path>/termalin-mcp
Or an MCP client config:
    { "mcpServers": { "termalin": { "command": "<path>/termalin-mcp" } } }
Reaches the hosts you tick in Settings → Security → Agent Access (MCP) (agent-only auth, no passwords on disk). Free on every plan; needs the app running for the live-terminal tools.

## Connect — hosted endpoint (no app running)
    {
      "mcpServers": {
        "termalin": {
          "url": "https://termal.in/api/v1/mcp",
          "headers": { "Authorization": "Bearer tk_live_…" }
        }
      }
    }
Create the API key in the web cabinet ("API keys & MCP"). It runs commands (on one server, several at once, or as background jobs), reads and writes files, queries databases and reads monitoring numbers and alerts on your Connector servers, even with nothing open on your machine, authenticating with a short-lived certificate. Keys can be scoped to specific servers, set to a command policy (Full access / Only listed commands / Read-only), given an expiry (In 90 days default, 30 days, 1 year, or Never), and revoked. After creating a key: a Test key button and ready snippets for Claude Code, Cursor, VS Code, Claude Desktop (via npx mcp-remote), Manus / n8n / LangChain and curl. Up to 10 keys on Pro, 25 on Team; a key needs a verified email (7-day grace).

The paths reach different hosts: the local server works the hosts you export from the app; the chat connectors and the API-key endpoint work your enrolled tunnel servers.

The hosted endpoint is listed in the official MCP Registry (registry.modelcontextprotocol.io) as `in.termal/termalin-web`.

Control: on your machine, agent access is off until you turn it on (separate toggles for "Agent in Terminal", "Let agents run commands", "Let agents use the local terminal", "Let agents query your databases"), and only the hosts you tick are exported — local agent commands are marked in the recording (green) and shown live in the watch grid. On the hosted side a Connector's AI access is ON by default (switch it off per server), and commands go to the cabinet audit log ("Ran a command") and, if enabled, a "Keep command output" log sealed with the master password. Access is per host locally (full / allowlist / blocked) and per connection or key on the hosted side. Hosted runs are rate-limited per account (about 60 a minute) and each call is time-boxed (about 90 s — use job_start for longer).

## Termalin for Chrome (browser extension)
A browser extension for Chrome, Microsoft Edge and Firefox (Chrome Web Store: https://chromewebstore.google.com/detail/lndnklpcljdenmlmgmcobchhdkpaahgi; Microsoft Edge Add-ons: https://microsoftedge.microsoft.com/addons/detail/dfdlpjonofnnhlldfdlgokfoapfgnnbl; Firefox Add-ons: https://addons.mozilla.org/firefox/addon/termalin/) adds a "Run on server" button to code blocks on ChatGPT, Claude, GitHub and Stack Overflow: pick a server, review the command, run (nothing runs until you press the button; risky commands ask twice), and "Insert into chat" sends the output back to the ChatGPT or Claude composer. A side panel lists your servers, open alerts and metrics with a command box and history; the toolbar badge counts open alerts; on Hetzner Cloud, DigitalOcean and AWS EC2 pages a known server IP gets a Run button. Nine languages. It signs in to your account like any AI app and follows the same per-server command rules.

---

# Documentation

## Install & first run
Download for Windows (.exe), macOS (.dmg), Linux (.AppImage, x86_64), or iPhone/iPad/Apple Watch (App Store) from https://termal.in/download/ — on Windows also via the Microsoft Store or `winget install Termalin.Termalin`, on macOS with Homebrew (`brew install --cask termalinapp/termalin/termalin`), on Windows with Scoop (`scoop bucket add termalin https://github.com/termalinapp/scoop-termalin` then `scoop install termalin`). Windows installs per-user (no admin). macOS is signed and notarized by Apple (opens normally); the Microsoft Store build is signed and installs with no warning; the standalone Windows .exe isn't code-signed yet (SmartScreen → More info → Run anyway); Linux → `chmod +x` the AppImage.

## First connection
Add host (address, port, username) → pick auth (password / private key / built-in key agent) → connect. First connect pins the server host key (TOFU). Every host is a tab; sessions survive switching and restarts.

## Hosts & folders
Host types: SSH, SFTP, FTP, Telnet, Serial/COM, database, S3, RDP/VNC remote desktops. Folders (drag & drop), tags, colours, snippets, saved port-forward tunnels (local/remote/SOCKS). Import from ~/.ssh/config, CSV, a Termalin JSON backup, PuTTY or MobaXterm (.mxtsessions or MobaXterm.ini); passwords are never imported; export to JSON / ssh config / CSV. Deleted hosts recover for 30 days; the cloud vault is versioned server-side. Host form also offers a jump host (bastion) field and a Connector type; snippets run into the focused session or broadcast to every connected host.

## Connectors
A Connector is a small agent installed with one command on a Linux, macOS or Windows server. Get the one-time install line from the cabinet's "Get install command" (tabs Linux / macOS and Windows; single-use, valid an hour): `curl -fsSL https://termal.in/i/<token> | sudo sh` on Linux/macOS, `irm https://termal.in/i/<token>.ps1 | iex` in PowerShell on Windows (it asks for administrator rights itself). It dials out to Termalin, so no inbound port and no SSH key on your device (short-lived SSH certificate). It is what lets the web terminal, remote desktops, AI apps and API keys, server monitoring and backups reach a server. Add one from the cabinet (Add Connector, or Hosts → + → Connector), the desktop host form's Connector type, or "Make it available" in the web terminal. Platforms: Linux x86_64 and aarch64 (termalin-agent.service via systemd, or `termalin-agent run`), macOS Apple Silicon or Intel (Remote Login switched on, a launchd daemon) and Windows x64 or ARM64 (Windows 10/11 and Windows Server; it installs the built-in OpenSSH Server if missing, keeps sshd on automatic start, runs as the TermalinAgent service and gives SSH sessions PowerShell — when it added OpenSSH, sshd listens on the machine only and port 22 stays closed). Uninstall: `termalin-agent uninstall` on macOS, `& "$env:ProgramFiles\Termalin\termalin-agent.exe" uninstall` on Windows. Settings: Name (what AI apps see), Login user (root if empty), AI access switch, Note for AI (returned as ownerNote by hosts_list; hosts_list also returns the server's public ip, the address its Connector connects from). On a Windows server, AI apps get ssh_exec and the job tools in PowerShell; the hosted SFTP and database tools are for Linux servers for now. Pro feature; Free has none; no cap on how many. Page: https://termal.in/connector/

Remote desktops: a Windows desktop over RDP (port 3389) or any VNC desktop (ports 5900–5999) opens in a browser tab or in the desktop app — through a Connector (no inbound port; private addresses only — the Connector's own machine, or 10.x/192.168.x/172.16–31.x on its network) or Direct (public addresses only; termal.in dials the desktop, the port must be open). In the cabinet, right-click a Connector or host → Remote desktop; in the app, add a host of type RDP or VNC. RDP/VNC are host types with a Connect choice — "Directly (the desktop has a public address)" or "Through Connector {name}"; the desktop app needs 0.1.48 or newer. 4 open desktops at once on Pro, 10 on Team; 30-minute idle timeout; protocol and port can be remembered on the host (never the password). Viewer: tabs, Send Ctrl+Alt+Del, fit or actual size; clipboard is paste-into-the-desktop only in the browser, both ways in the desktop app (per-host switch). A desktop opened through a Connector on the Connector's own machine (empty address, 127.0.0.1, localhost or ::1) gets a Files button that browses that machine's files through the same Connector with no key (Windows drive paths work); direct desktops and other addresses get no button. Brakes: three failed sign-ins in a row pause a desktop 30 minutes, doubling up to a day; direct mode allows at most 30 new sessions and 5 different addresses an hour. The RDP stream is relayed by termal.in in memory and not stored; with Network Level Authentication (the Windows default) the password is never in the clear; the RDP certificate is pinned on first use. Direct VNC is unencrypted between termal.in and the server, so a Connector is the better path for VNC; the VNC password goes to the server through the tunnel. Kerberos isn't supported (local account or NTLM). On the Connector path the desktop app opens the encrypted session itself (termal.in only passes bytes). Direct from the desktop app is free (our servers aren't involved); through a Connector, and anything in the browser, is Pro/Team. Docs: https://termal.in/rdp-client/ · https://termal.in/web-rdp-client/ · https://termal.in/remote-desktop-without-port-forwarding/

## Windows servers
Run the Windows install line (irm https://termal.in/i/<token>.ps1 | iex, approve the UAC prompt) on Windows 10/11 or Windows Server and the Connector adds the built-in OpenSSH Server if missing (sshd stays on automatic start), makes PowerShell the SSH login shell, and runs as the TermalinAgent service; when it added OpenSSH, sshd listens on the machine itself only and port 22 stays closed (an OpenSSH Server that was already there is left as it was). You then get a PowerShell terminal (browser or app), an SFTP file browser, an RDP desktop to the machine with the Files button, and monitoring and alerts. For AI apps, ssh_exec and the job tools run in PowerShell; the hosted SFTP and database tools are for Linux servers for now. Pages: https://termal.in/windows-server-ssh/ · https://termal.in/windows-server-monitoring/

## SSH keys & the key agent
Generate Ed25519/RSA or import (passphrase supported). Built-in SSH key agent: unlock once, it signs for your sessions and agents without re-typing; keys never written to disk in plaintext; per-key re-lock timeout. Speaks the standard SSH agent protocol (named pipe on Windows, Unix socket on macOS/Linux).

## Master password & locks
Encrypts the vault (PBKDF2-HMAC-SHA256, 600,000 iterations). No reset by email: an optional recovery code (Settings → Security → "Recovery code", stored on your account, so needs cloud sync) lets you pick a new master password from the lock screen or "Forgot password"; without one, lost means lost. Auto-lock on inactivity, lock on minimize, unlock with biometrics (Touch ID on macOS, Windows Hello on Windows, the platform equivalent elsewhere), optional "Remember master password" in the OS keystore (Windows DPAPI, macOS Keychain, Linux Secret Service). Two extra lock options: "Also lock SSH keys" (stop serving keys to agents while locked) and "Pause AI agents while locked" (by default connected agents keep working behind the lock; this refuses them until you unlock). Locking overlays the app; sessions stay connected.

## Sync & account
Account = cross-device sync; vault encrypted on-device before upload (server stores only ciphertext). The app works fully offline. Sync, cloud recordings, the web cabinet and web terminal, Connectors, the hosted MCP and API keys, and server monitoring are Pro; the full local desktop app is free forever (free browser demo of the cabinet). Settings → Account also holds Activity & devices, synced Command history (by host; 90 days Pro, 1 year Team) and Refer a friend. Browser cabinet (https://termal.in/account): real terminal + SFTP/FTP/S3 + snippets + replay on any device, plus two-factor sign-in (TOTP + backup codes), passkeys, sign-in with GitHub/Google/Apple, and an Activity log; recordings decrypt client-side. Right-click the web terminal for "Copy screen" or "Select text…" (last 2,000 lines, with Copy selected / Copy all).

## Recording & replay
Records sessions (asciicast) with a scrubbable timeline. Captures output + event markers, never raw keystrokes. Markers: green = agent, amber = you. Retention window prunes old recordings.

## Backups
Encrypted backups of files on a server with a Connector, on a schedule (hourly, daily at an hour UTC — 03:00 default, weekly on Sunday, or manual), set up in the cabinet (Account → Backups) or in the desktop app (Settings → Account → Backups; a job's key made in one client opens in the other): paths (absolute), exclude patterns, databases to dump, how many copies to keep (1–365, default 7), a Read speed limit (MB/s; 20 by default, 0 = no limit), where to store. A job can also dump PostgreSQL and MySQL/MariaDB — on the server or inside a Docker container, one database or all — into the same encrypted archive, with a README inside on how to restore; no database password is kept at Termalin (it uses the server's own local trust via .pgpass / my.cnf, or the container's settings), and a dump needs free disk on the server about its own size while it runs. Nothing installed on the server: tar runs at the lowest CPU/disk priority (nice/ionice) and the archive is read back at the capped speed. Each archive is encrypted for a key made in the browser or the app; the private half is protected by the master password, so Termalin's storage, an S3 bucket and your own server hold ciphertext only (while an archive is being encrypted the stream passes through the backend in memory — not end-to-end). Download the raw archive or Decrypt & save to a .tar.gz. Storage destinations under "Your storage": Termalin's pool shared with recordings (25 GB Pro, 100 GB Team; recordings have priority — a backup that would not fit does not start), the owner's S3-compatible bucket (not counted), or "My server (via Connector)" — over SFTP to another of the owner's servers that has a Connector, such as a second VPS or a home NAS (default folder termalin-backups in the home, relative or absolute, created if missing; not counted). Archive lists show where each file lives. Rotation keeps the newest N. Jobs per account: 20 Pro / 100 Team; largest single archive 5 GB Pro / 20 GB Team. Extra storage: +100 GB $2.99/mo or +1 TB $19.99/mo from balance (paid plans; shared by recordings and backups). A failed scheduled run is sent like an alert; Run now shows the error. File backups run on Linux, Windows and macOS servers; database backups on Linux and macOS. MCP: backup_create, backup_list, backup_job_create (full-access callers; the agent never reads an archive; backup_job_create drafts a job for the owner to confirm). Page: https://termal.in/server-backups/

## Watch grid
Mirror every open session at once side by side; tiles are live and read-only until you tap one to select it (the selected tile takes your keystrokes, the rest stay read-only). Agent-driven sessions highlighted. "Send to all sessions" runs a command across every connected host.

## SFTP & the editor
Built-in editor (syntax highlighting, line numbers, find & replace) + viewers for images, video/audio, PDF, SVG, Markdown, CSV, archives. Large media streams via range requests.

## Database client
Thirteen engines in one client: PostgreSQL, MySQL/MariaDB, SQLite, SQL Server, MongoDB, Redis, ClickHouse, Elasticsearch/OpenSearch, Cassandra/ScyllaDB, Neo4j, InfluxDB, RabbitMQ, Cloudflare D1. Connect directly, through an SSH tunnel, or to a private database through a keyless Connector. SQL editor with results grid; agents get read-only-by-default access via the data_* MCP tools with a per-connection policy. Works in the browser cabinet too — credentials decrypt client-side and are never stored server-side. Details: https://termal.in/database-client/

## Server monitoring & alerts
Page: https://termal.in/server-monitoring/. Works for every server that has a Termalin Connector; nothing extra to install. Once a minute Termalin reads a few numbers over the Connector's existing connection — on Linux from /proc, df, ps and the like; on Windows through CIM/WMI (CPU, memory, page file, fixed drives with the system drive standing in for "/", network, disk traffic, processes, uptime); on macOS from the system's own tools (load, CPU, memory, swap, volumes, network, processes, uptime) — a few milliseconds of CPU and about a kilobyte a minute, nothing extra installed. Containers, failed systemd services and PSI pressure are read on Linux only; an unknown system shows "Monitoring for this system isn't available yet" and is never counted as down. On by default for every Connector; one switch for all servers and one per server (web cabinet → Server metrics, or the desktop app → Settings → Account → Monitoring). Switching it off erases what was collected for that server; alerts only work for servers with monitoring on.
Dashboards (web cabinet, https://termal.in/account → Server metrics): CPU (busy/user/system/iowait/steal), load average, memory and swap, disk space and inodes, network in/out, disk I/O and disk busy, pressure (PSI), processes, TCP sockets, open files, containers and failed services, failed SSH sign-ins, pending security updates. Tables: disks, top processes by CPU, containers, TLS certificates with days to expiry, failed services, listening ports. Time ranges from 15 minutes to the plan's history.
History: 90 days on Pro, two years on Team. The recent two weeks at one-minute detail; older history as five-minute then hourly averages that keep the peak of each interval.
Alerts, with default thresholds and nothing to configure: disk nearly full (90% warning, 95% critical) or forecast to fill within a day; inodes running out; memory pinned; load high for a sustained time; CPU time taken by the hypervisor (steal); a failed systemd service; a container that keeps restarting or is unhealthy; an out-of-memory kill; a TLS certificate about to expire (14 days, critical at 3); the server restarted; the server offline (after three minutes, so a reboot is not an alert); a connection that keeps dropping. Thresholds can be changed.
Channels: email (default), push to the iOS app, Telegram (one tap to connect a bot), a webhook that Slack and Discord accept as is; webhook requests are signed (HMAC-SHA256).
Quiet by design: one message when a problem opens and one when it clears; several problems within a few minutes arrive as one message; a critical one never waits; a problem that comes back the same day is not sent again unless it is critical and lasts; on the first day a server is monitored only critical alerts are sent; routine failed units and leftover expired certificates are ignored; mute one kind of alert on one server, or a whole server.
AI apps: through the hosted MCP endpoint, Claude and ChatGPT read the numbers (server_metrics) and the alerts (alerts_list).
Plans: part of Pro and Team (it needs a Connector, a paid-plan feature; the 14-day Pro trial includes it). Not on Free.
Privacy: these numbers are not end-to-end encrypted — the service has to read them to draw charts and raise alerts. What is read is listed at https://termal.in/privacy/ under "Server metrics and alerts".
The desktop app shows an overview and 1h/24h/7d charts (Settings → Account → Monitoring), with the rarer panels in the web cabinet; the iOS app receives the pushes. Not available: per-team alert routing, log collection, custom metrics, uptime checks from outside, status pages, PagerDuty/Opsgenie integrations. It is a zero-setup baseline, not a full observability stack.
Alert settings also hold "Send a test" (per channel) and "Pause all alerts"; the desktop's Settings → Security → "Server alerts" pings this device when a Connector drops off or comes back.

## AI assistant
Built-in AI assistant (Settings → Security → "AI assistant"): session summaries, "Explain with AI" on selected output (what it means / likely cause / what to do, plus a "Check:" block of read-only commands), "Ask AI for a command", "Summarize with AI" on a recording, describe a Connector's server. Built-in (Anthropic) allowance: 400 requests a month on Pro, 1,000 on Team, 40 on the trial (plus 80 a day); none on Free. Or bring your own Anthropic key (no allowance, any plan), or use your own endpoint — any OpenAI-compatible API (OpenAI, Gemini, OpenRouter, Groq, DeepSeek) or a local model via Ollama or LM Studio, in which case requests go straight from the device and Termalin's server sees none of it. Built-in path: text passes through Termalin's server to Anthropic, not stored or logged (only request counts kept); recordings decrypt on-device only when asked. Free plan works with your own key or a local model.

## Updates
Silent auto-update; each release signed with an offline key; the app verifies signature + checksum before installing (a bad update server can withhold but not inject). Check manually from Settings → About → "Check for updates".

## Troubleshooting
SmartScreen: More info → Run anyway (standalone Windows .exe not code-signed yet), or install the signed Microsoft Store build. Local agent can't connect: app running + agent toggles on + host allows headless (key unlocked). Chat app sees no servers: only servers running a Connector are visible — install one (termal.in/account, or "Make it available" in the web terminal); if connected but hidden, turn on AI access in the Connector settings; if the plan doesn't include it, the trial ended (hosted MCP is Pro). API key refused: check the reason next to the key (copy cut off / expired / plan / unverified email / revoked) and use Test key; a command that runs out of time (60 s by default, timeout up to 300 s; some chat apps stop waiting sooner) should use job_start. Forgot master password: use the recovery code if you set one; otherwise unrecoverable — reset the app to start fresh. A Termalin user hit your server: report at https://termal.in/abuse/.

---

# Pricing
No plan limits hosts, keys, devices or Connectors. Free ($0) — full local desktop app (SSH/SFTP, database client, local vault, live status bar, recording & replay, watch grid, local MCP server, the AI assistant with your own key or a local model) + a free browser demo. Pro ($10/mo, or $8/mo billed yearly; 14-day trial for every new account, 28 days if referred, one trial per device or Connector server) — cloud E2E sync + the browser cabinet + cloud recordings + command history + Connectors + hosted MCP for AI apps + API keys (10) + server monitoring and alerts (90 days of metrics history) + encrypted server backups + 25 GB of cloud storage shared by recordings (kept 90 days) and backups + 400 AI assistant requests a month. Team ($19 per user/mo, or $15 billed yearly) — shared vault, session sharing, roles, consolidated billing (per seat), two years of metrics history, 100 GB of cloud storage shared by recordings (kept a year) and backups, 1,000 AI requests a month per seat. Enterprise — custom (SSO/SCIM, SLA). Lifetime Pro license for early backers: one-time, 100 total in three price steps — the first 25 at $149 are sold out, it is $199 now, and $249 for the last 50; once they are gone the offer ends. Pay by card (Creem) or crypto (NOWPayments), or from a wallet balance. See https://termal.in/pricing/.

# Security
End-to-end encryption: vault encrypted on-device with a master-password-derived key (PBKDF2 + AES-256-GCM) before sync; the server stores only ciphertext and can't read it. Master password can't be reset. Server identity is verified before the app sends credentials. Keyless private-host access via an SSH certificate authority + tunnel agent. Full model: https://termal.in/security/ · https://termal.in/.well-known/security.txt