---
title: "Command-Line Options"
---
DBHub connects to your database in one of two ways:
- **A DSN** — one connection string for a single database.
- **A [TOML file](/config/toml)** — passed with `--config`, for one or more databases plus per-source and per-tool settings.
Choose one. A TOML file defines its sources itself, so `--config` and `--dsn` cannot be combined.
Environment variables are a different matter: `DSN` and `DB_*` stay available to a TOML file through [`${VAR}` interpolation](/config/toml#environment-variable-interpolation), which is the recommended way to keep credentials out of the file.
When you use a DSN, DBHub takes it from the first of:
1. `--dsn` flag
2. `DSN` environment variable
3. `DB_*` environment variables
4. `.env` file (`.env.local` in development, `.env` in production)
Every other option — transport, port, host, and so on — is set by flag or environment variable, in the same order:
1. Command-line flag
2. Environment variable
3. `.env` file
4. Built-in default
This page covers command-line flags and environment variables. For TOML configuration, see [TOML Configuration](/config/toml).
### `--transport`
Transport protocol for [MCP communication](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports). Env: `TRANSPORT`.
**Options:**
- `stdio` - For desktop tools (Claude Desktop, Claude Code, Cursor). Pure MCP-over-stdio with no HTTP server.
- `http` - For browser and network clients. Starts HTTP server with MCP endpoint, workbench, and API.
Both transports serve the stateless **2026-07-28** MCP protocol revision natively and fall back to the 2025-era protocol for older clients on the same endpoint — no configuration needed. On `http`, 2026-era clients send the standard `Mcp-Method` / `Mcp-Name` headers with every request, so a fronting gateway or WAF can route and rate-limit individual tools without parsing request bodies.
| Feature | `stdio` | `http` |
|---------|:-------:|:------:|
| MCP communication | stdin/stdout | HTTP POST `/mcp` |
| Workbench | ❌ | ✅ `http://host:port/` |
| Health check | ❌ | ✅ `/healthz` |
| API | ❌ | ✅ `/api/xxx` |
| Multiple instances | ✅ No port conflicts | Requires different ports |
```bash
# stdio (default) - for Claude Desktop, Claude Code, Cursor
# No HTTP server started
npx @bytebase/dbhub@latest --transport stdio --dsn "..."
# http - for web clients, workbench, and remote access
npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "..."
```
### `--port`
HTTP server port. Only used when `--transport=http`. Ignored for stdio transport. Env: `PORT`.
```bash
npx @bytebase/dbhub@latest --transport http --port 3000 --dsn "..."
```
### `--host`
HTTP bind address. Only used when `--transport=http`. Ignored for stdio transport. Env: `DBHUB_HOST`.
```bash
# Restrict to loopback (recommended for production)
npx @bytebase/dbhub@latest --transport http --host 127.0.0.1 --port 8080 --dsn "..."
# Bind to a specific interface
npx @bytebase/dbhub@latest --transport http --host 10.0.0.5 --port 8080 --dsn "..."
# IPv6 loopback
npx @bytebase/dbhub@latest --transport http --host ::1 --port 8080 --dsn "..."
```
The default `0.0.0.0` exposes DBHub on every network interface. For production, set `--host 127.0.0.1` and place DBHub behind a reverse proxy (nginx/Caddy) or restrict with a firewall, or configure `--auth-token` (see below) to require a bearer token on every request.
### `--allowed-hosts`
Comma-separated list of additional hostnames the HTTP transport accepts in the
`Host` (and `Origin`) headers. This is DBHub's **DNS-rebinding protection**:
requests whose `Host` is not on the list are rejected with `403`, so a
malicious web page cannot rebind a hostname to your DBHub instance and drive
its MCP tools from the victim's browser. Only used when `--transport=http`. Env: `DBHUB_ALLOWED_HOSTS`.
The list always includes loopback (`localhost`, `127.0.0.1`, `[::1]`). When
bound to a wildcard address (the default `0.0.0.0` / `::`), this machine's own
hostname and external IP addresses are added automatically, so reaching DBHub
by IP or machine name works without any extra configuration. You only need
this flag for **other** names that resolve to DBHub — most commonly a
reverse-proxy or public DNS name.
```bash
# Serve behind a public/reverse-proxy hostname
npx @bytebase/dbhub@latest --transport http --allowed-hosts "dbhub.example.com" --dsn "..."
# Multiple hostnames
npx @bytebase/dbhub@latest --transport http --allowed-hosts "dbhub.example.com,db.internal" --dsn "..."
# Disable the check entirely (only when fronted by your own auth/proxy)
npx @bytebase/dbhub@latest --transport http --allowed-hosts "*" --dsn "..."
```
A port in an entry is ignored — only the hostname is matched. IPv6 literals
must be bracketed, e.g. `[2001:db8::1]`. The active allow-list is printed at
startup. If a legitimate client gets a `403` "Host ... is not allowed", add
its hostname here.
`--allowed-hosts "*"` turns off DNS-rebinding protection. Use it only when
DBHub sits behind your own authentication and/or proxy.
### `--auth-token`
Comma-separated list of bearer tokens required on every HTTP request. Only used when `--transport=http`. Unset by default — auth is off unless you configure this. Env: `DBHUB_AUTH_TOKEN`.
Clients must send a matching token as `Authorization: Bearer `; requests without one get `401 Unauthorized` with a `WWW-Authenticate: Bearer` header. `/healthz` is exempt so uptime monitors don't need a token.
```bash
# Single token
npx @bytebase/dbhub@latest --transport http --auth-token "s3cr3t-token" --dsn "..."
# Multiple tokens (rotate without downtime, or issue one per client)
npx @bytebase/dbhub@latest --transport http --auth-token "token-for-ci,token-for-agent" --dsn "..."
```
Client request (`/api/sources` is a plain `GET`; the MCP endpoint itself
requires a JSON-RPC POST body, so it's not a copy-pasteable example):
```bash
curl -H "Authorization: Bearer s3cr3t-token" http://localhost:8080/api/sources
```
Configuring a token *is* the opt-in — there's no separate "require auth" flag to remember. A comma-separated list lets you rotate a leaked or expiring token by adding the new one, redeploying, and then removing the old one, and lets you hand different tokens to different clients so one can be revoked without affecting the others.
This is a flat shared-secret check, not OAuth — it answers "does this request have the secret," not "who is this user" (no per-user scopes or audit trail). If you need real identity-based authorization, front DBHub with your own OAuth-aware proxy or IdP-integrated gateway instead.
### `--dsn`
Database connection string (Data Source Name). Format: `database_type://username:password@host:port/database_name?options`. Env: `DSN` (see the resolution order at the top of this page).
```bash
# Format: postgres://[user]:[password]@[host]:[port]/[database]?[options]
postgres://myuser:mypassword@localhost:5432/mydb
```
```bash
# Format: mysql://[user]:[password]@[host]:[port]/[database]?[options]
mysql://root:password@localhost:3306/mydb
```
```bash
# Format: mariadb://[user]:[password]@[host]:[port]/[database]?[options]
mariadb://root:password@localhost:3306/mydb
```
```bash
# Format: sqlserver://[user]:[password]@[host]:[port]/[database]?[options]
sqlserver://sa:YourPassword123@localhost:1433/mydb
# Named instance (e.g., ENV1, ENV2, ENV3)
sqlserver://sa:YourPassword123@localhost:1433/mydb?instanceName=ENV1
# Windows/NTLM authentication
sqlserver://jsmith:secret@sqlserver.corp.local:1433/mydb?authentication=ntlm&domain=CORP
# Azure AD authentication (password optional/empty)
sqlserver://username@localhost:1433/mydb?authentication=azure-active-directory-access-token
```
Integrated security (a trusted connection using the logged-in
Windows user, with no username/password in the DSN) is **not
supported**. DBHub uses the pure-JS `tedious` driver, which has no
SSPI/Kerberos support. Note that `authentication=ntlm` still
requires an explicit username and password in the DSN, so it is not
a trusted connection. Use SQL authentication or, for Azure SQL,
Azure AD instead.
```bash
# Format: oracle://[user]:[password]@[host]:[port]/[service_name]?[options]
oracle://app:secret@localhost:1521/FREEPDB1
# Old-style SID instead of a service name
oracle://app:secret@localhost:1521/?sid=ORCL
# TCPS (TLS): require = encrypted, verify-full = certificate DN matched against the host
oracle://app:secret@db.example.com:2484/PROD?sslmode=verify-full
# Mutual TLS with a PEM wallet (e.g. Autonomous Database), percent-encoded values
oracle://app:secret@adb.example.com:1522/abc123_mydb_tp.adb.oraclecloud.com?sslmode=require&wallet_location=%2Fopt%2Fwallet&wallet_password=w%40llet
```
The path is the **service name** (e.g. `FREEPDB1` on Oracle Database
Free). DBHub uses node-oracledb in Thin mode, so no Oracle Instant
Client is needed. `verify-full` validates the server certificate
against the system trust store; `sslrootcert` is not supported for
Oracle.
```bash
# Format: clickhouse://[user]:[password]@[host]:[port]/[database]?[options]
clickhouse://default:secret@localhost:8123/analytics
# The out-of-the-box `default` user has no password
clickhouse://default:@localhost:8123/default
# ClickHouse Cloud: HTTPS on port 8443
clickhouse://default:secret@abc123.us-east-1.aws.clickhouse.cloud:8443/default?sslmode=verify-full
```
The port is the **HTTP interface** port (`8123`, or `8443` with
`sslmode=require` / `verify-full`), not the native protocol port.
```bash
# Absolute path (Unix/Linux/macOS)
sqlite:///var/lib/data/mydb.db
# Absolute path (Windows)
sqlite:///C:/Users/YourName/data/database.db
# Relative path
sqlite:///./data/mydb.db
# Home directory
sqlite:///~/data/mydb.db
# In-memory
sqlite:///:memory:
```
After three slashes the path is **absolute**: `sqlite:///mydb.db` is
`/mydb.db` at the root of the filesystem, not `mydb.db` in the current
folder. For a file next to you, write `sqlite:///./mydb.db`.
A relative path is resolved against the directory DBHub is started from,
or against the config file's directory when the DSN comes from a
[TOML file](/config/toml). The startup output prints the absolute path
DBHub opened.
A `?` ends the path, so write a literal `?` in a file or directory name
as `%3F` (and a literal `%3F` or `%25` as `%253F` / `%2525`). Spaces and
other characters are written as they are.
If the file does not exist, DBHub creates an empty database there and
prints a warning naming it, unless every tool on the source is
[read-only](/config/read-only-mode), in which case startup fails. If the
file cannot be opened at all, startup fails with an error naming the
path and what is missing.
**DSN Query Parameters:**
| Parameter | Databases | Description | Example |
|-----------|-----------|-------------|---------|
| `sslmode` | PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, ClickHouse | SSL mode: `disable`, `require`, `verify-ca`, `verify-full` | `?sslmode=require` |
| `sslrootcert` | PostgreSQL | CA certificate path (requires `verify-ca` or `verify-full`; rejected with `require`, `disable` or no `sslmode`) | `?sslrootcert=~/.ssl/ca.pem` |
| `sslcert` | PostgreSQL | PEM client certificate for client certificate authentication (set with `sslkey`; requires `require`, `verify-ca` or `verify-full`) | `?sslcert=~/.ssl/client.crt` |
| `sslkey` | PostgreSQL | Unencrypted PEM private key for `sslcert` | `?sslkey=~/.ssl/client.key` |
| `instanceName` | SQL Server | Named instance | `?instanceName=SQLEXPRESS` |
| `authentication` | SQL Server | Auth method: `ntlm`, `azure-active-directory-access-token` | `?authentication=ntlm` |
| `domain` | SQL Server | Windows domain (with `authentication=ntlm`) | `?domain=CORP` |
| `applicationIntent` | SQL Server | `ReadOnly` routes to a readable secondary (Always On AG, Azure SQL Database read scale-out, Managed Instance Business Critical); `ReadWrite` is the default. Key and value are case-insensitive | `?applicationIntent=ReadOnly` |
| `sid` | Oracle | Connect by SID instead of service name | `?sid=ORCL` |
| `wallet_location` | Oracle | Directory containing the PEM wallet (`ewallet.pem`) for mutual TLS (requires `require` or `verify-full`; `~/` is expanded) | `?wallet_location=~%2Fwallets%2Fadb` |
| `wallet_password` | Oracle | Password of an encrypted `ewallet.pem` (requires `wallet_location`; masked in logs) | `?wallet_password=...` |
| `ssl_server_cert_dn` | Oracle | Expected server certificate DN, for hosts whose name does not match the certificate; always checked when set | `?ssl_server_cert_dn=CN%3Ddb.example.com` |
**SSL/TLS Options:**
| Database | `disable` | `require` | `verify-ca` | `verify-full` | Without `sslmode` |
| ---------- | :-------: | :-------: | :---------: | :----------: | :-----: |
| PostgreSQL | ✅ | ✅ | ✅ | ✅ | Unencrypted |
| MySQL | ✅ | ✅ | ✅ | ✅ | Unencrypted |
| MariaDB | ✅ | ✅ | ✅ | ✅ | Unencrypted |
| SQL Server | ✅ | ✅ | ❌ | ✅ | Unencrypted |
| Oracle | ✅ | ✅ | ❌ | ✅ | Plain TCP (`tcps://` only with `require`/`verify-full`) |
| ClickHouse | ✅ | ✅ | ❌ | ✅ | Plain HTTP (HTTPS only with `require`/`verify-full`) |
| SQLite | ❌ | ❌ | ❌ | ❌ | N/A (file-based) |
- No `sslmode`: the connection is **not encrypted** — the same as `disable`. Set `require` or a verify mode for any database reached over a network you don't control.
- `sslmode=disable`: All SSL/TLS encryption is turned off. Data is transmitted in plaintext.
- `sslmode=require`: Connection is encrypted, but the server's certificate is not verified.
- `sslmode=verify-ca`: SSL with CA certificate verification, but no hostname check. **PostgreSQL, MySQL, and MariaDB.** On PostgreSQL use `sslrootcert` to specify the CA certificate path.
- `sslmode=verify-full`: SSL with CA certificate and hostname verification. **All network databases.** On PostgreSQL use `sslrootcert` to specify the CA certificate path. MySQL, MariaDB, SQL Server and ClickHouse use Node's configured trust roots; set `NODE_EXTRA_CA_CERTS` to a PEM CA bundle before process startup if an additional CA is needed (e.g. the Amazon RDS CA bundle). Oracle uses the system trust store.
Unlike libpq, DBHub does not upgrade `sslmode=require` to `verify-ca` when `sslrootcert` is present: that combination is rejected at startup, so set `sslmode=verify-ca` explicitly. libpq's `allow` and `prefer` modes are not supported for PostgreSQL either; use `require` (or a verify mode) instead. MySQL and MariaDB likewise reject any value other than the four above, including MySQL's own `PREFERRED` / `VERIFY_IDENTITY` spellings.
```bash
# Examples
postgres://user:password@localhost:5432/dbname?sslmode=disable
postgres://user:password@localhost:5432/dbname?sslmode=require
postgres://user:password@rds-host:5432/dbname?sslmode=verify-ca&sslrootcert=~/.ssl/rds-ca.pem
postgres://user:password@pg-host:5432/dbname?sslmode=require&sslcert=~/.ssl/client.crt&sslkey=~/.ssl/client.key
mysql://user:password@mysql-host:3306/dbname?sslmode=verify-full
sqlserver://jsmith:secret@localhost:1433/mydb?authentication=ntlm&domain=CORP
oracle://app:secret@db.example.com:2484/PROD?sslmode=verify-full
clickhouse://default:secret@abc123.us-east-1.aws.clickhouse.cloud:8443/default?sslmode=verify-full
```
**Environment Variables (Alternative to `--dsn`)**
Recommended for databases with complex passwords containing special characters:
| Variable | Type | Description |
|----------|------|-------------|
| `DB_TYPE` | string | Database type: `postgres`, `mysql`, `mariadb`, `sqlserver`, `oracle`, `clickhouse`, `sqlite` |
| `DB_HOST` | string | Database server hostname (not needed for SQLite) |
| `DB_PORT` | number | Database server port. Default: PostgreSQL (`5432`), MySQL/MariaDB (`3306`), SQL Server (`1433`), Oracle (`1521`), ClickHouse (`8123`, its HTTP port) |
| `DB_USER` | string | Database username (not needed for SQLite) |
| `DB_PASSWORD` | string | Database password (not needed for SQLite). Supports special characters without URL encoding. |
| `DB_NAME` | string | Database name, or the SQLite file path (a relative path is resolved against the working directory) |
```bash
export DB_TYPE=postgres
export DB_HOST=localhost
export DB_PORT=5432
export DB_USER=myuser
export DB_PASSWORD='p@ss:word#123'
export DB_NAME=mydb
npx @bytebase/dbhub@latest
```
### `--id`
Source ID for the database given by the DSN (default: `default`). Env: `ID`.
The ID labels the source in tool output (`source_id`), the workbench and the request trace. It does **not** change tool names: a DBHub instance with a single source always exposes the bare `execute_sql` and `search_objects`. Tool names are suffixed only when a [TOML file](/config/toml) defines two or more sources — see [Tool Naming](/tools/overview#tool-naming).
```bash
npx @bytebase/dbhub@latest --id prod --dsn "postgres://user:pass@prod-host:5432/db"
```
To tell several single-database instances apart in an MCP client, give each server entry its own name in the client's configuration (`dbhub-prod`, `dbhub-staging`); clients namespace tools by server.
Cannot be used with `--config` (TOML configuration). TOML config defines source IDs directly in the configuration file. Use command-line DSN configuration instead if you need the `--id` flag.
### `--demo`
Run DBHub with a bundled SQLite sample "employee" database for testing.
```bash
npx @bytebase/dbhub@latest --demo --transport http --port 8080
```
### `--config`
Path to a TOML configuration file, for managing multiple database connections and advanced configurations.
```bash
npx @bytebase/dbhub@latest --config ./dbhub.toml --transport http --port 8080
```
See [TOML Configuration](/config/toml) for the complete reference, including source options, tool options, SSH tunnels, and custom tools.
A TOML file defines its own sources and source IDs, so `--config` is mutually exclusive with `--dsn` and `--id`. Use either a TOML file or command-line/environment configuration.
### SSH Tunnel Options
SSH tunnel configuration for connecting to databases through bastion/jump hosts.
| Option | Env | Type | Description |
|--------|-----|------|-------------|
| `--ssh-host` | `SSH_HOST` | string | SSH server hostname or alias from `~/.ssh/config` |
| `--ssh-port` | `SSH_PORT` | number | SSH server port (default: `22`) |
| `--ssh-user` | `SSH_USER` | string | SSH username |
| `--ssh-password` | `SSH_PASSWORD` | string | SSH password (for password auth) |
| `--ssh-key` | `SSH_KEY` | string | Path to SSH private key file, or a base64-encoded private key. Auto-detects `~/.ssh/id_rsa`, `~/.ssh/id_ed25519`, etc. if not specified |
| `--ssh-passphrase` | `SSH_PASSPHRASE` | string | Passphrase for encrypted SSH key |
| `--ssh-agent` | `SSH_AUTH_SOCK` | string | Path to an SSH agent socket (ssh-agent, 1Password, etc.). Makes `--ssh-password` / `--ssh-key` optional |
| `--ssh-proxy-jump` | `SSH_PROXY_JUMP` | string | ProxyJump hosts for multi-hop SSH. Format: `[user@]host[:port]` (comma-separated for chains) |
| `--ssh-keepalive-interval` | `SSH_KEEPALIVE_INTERVAL` | number | Seconds between SSH keepalive packets (default: `0`, disabled). Set it when an idle tunnel is dropped by a firewall or NAT |
| `--ssh-keepalive-count-max` | `SSH_KEEPALIVE_COUNT_MAX` | number | Missed keepalive responses tolerated before the tunnel is considered dead (default: `3`) |
**Examples:**
```bash
# Password auth
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host bastion.example.com --ssh-user ubuntu --ssh-password mypassword
# Key-based auth
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host bastion.example.com --ssh-user ubuntu --ssh-key ~/.ssh/id_rsa
# ProxyJump (single hop)
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host target.internal --ssh-proxy-jump bastion.example.com
# ProxyJump (multi-hop: bastion1 → bastion2 → target)
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host target.internal --ssh-proxy-jump "bastion1.com,admin@bastion2:2222"
# SSH config alias (resolves host, user, key, and ProxyJump from ~/.ssh/config)
npx @bytebase/dbhub@latest --dsn "..." --ssh-host mybastion
# Base64-encoded private key (useful in containerized/cloud environments)
export SSH_KEY=$(base64 < ~/.ssh/id_rsa)
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host bastion.example.com --ssh-user ubuntu
# SSH agent (ssh-agent, 1Password, etc.) — no key or password needed
export SSH_AUTH_SOCK="$HOME/Library/Group Containers/2BUA8C4S2C.com.1password/t/agent.sock"
npx @bytebase/dbhub@latest --dsn "..." \
--ssh-host bastion.example.com --ssh-user ubuntu
```
- `--ssh-key` / `SSH_KEY` accepts either a file path or a base64-encoded private key. DBHub automatically detects the format: it first tries to read the value as a file path, and if that fails, decodes it as base64.
- When an SSH agent is available (`--ssh-agent`, or the standard `SSH_AUTH_SOCK` environment variable), DBHub offers it to every host in the chain, after any password or key. With an agent, `--ssh-password` / `--ssh-key` are optional. In TOML, `ssh_agent` sets the socket per source. An explicitly configured socket that does not exist is an error; a stale `SSH_AUTH_SOCK` is ignored with a warning. MCP clients launched from a GUI often don't inherit your shell's `SSH_AUTH_SOCK` — set it in the client's `env` block or use `--ssh-agent` / `ssh_agent`. The `IdentityAgent` directive in `~/.ssh/config` is not read.
- A key picked up from `~/.ssh/config` (an `IdentityFile` or a default `~/.ssh/id_*` key) that cannot be used — for example an encrypted key with no passphrase, or an `IdentityFile` pointing at a `.pub` file — is skipped with a warning when a password or agent is available, as `ssh` does. A key given explicitly (`--ssh-key`, `SSH_KEY`, `ssh_key`) is never skipped.
- When `--ssh-host` is a plain alias (no dots, not an IP address), DBHub automatically resolves it from `~/.ssh/config`, reading the `HostName`, `User`, `IdentityFile`, and `ProxyJump` directives. Explicit flags always override values from the config file.
- `ProxyJump` hops that are themselves `~/.ssh/config` aliases are resolved recursively — each hop uses its own `HostName`/`User`/`Port`/`IdentityFile` (and its own nested `ProxyJump`), matching how `ssh` connects. Cyclic `ProxyJump` chains are rejected with an error.
- ProxyCommand is not supported (requires shell execution). Use ProxyJump instead.
- Path expansion for `~/` is supported in file paths.
## Quick Reference
| CLI Option | Env | Type | Description |
|------------|---------------------|------|-------------|
| `--transport` | `TRANSPORT` | string | Transport mode: stdio or http (default: `stdio`) |
| `--port` | `PORT` | number | HTTP server port (http transport only, default: `8080`) |
| `--host` | `DBHUB_HOST` | string | HTTP bind address (http transport only, default: `0.0.0.0`) |
| `--allowed-hosts` | `DBHUB_ALLOWED_HOSTS` | string | Extra hostnames accepted in Host/Origin headers (http transport only, default: loopback + this machine) |
| `--auth-token` | `DBHUB_AUTH_TOKEN` | string | Comma-separated bearer token(s) required on requests (http transport only, default: auth disabled) |
| `--demo` | - | boolean | Use sample employee database |
| `--id` | `ID` | string | Source ID for the DSN's database (default: `default`) |
| `--config` | - | string | Path to TOML config file (not loaded unless given) |
| `--dsn` | `DSN` | string | Database connection string (or use the `DB_*` variables, `--demo`, or `--config`) |
| - | `DB_TYPE` | string | Database type |
| - | `DB_HOST` | string | Database hostname |
| - | `DB_PORT` | number | Database port (varies by type) |
| - | `DB_USER` | string | Database username |
| - | `DB_PASSWORD` | string | Database password |
| - | `DB_NAME` | string | Database name or SQLite file path |
| `--ssh-host` | `SSH_HOST` | string | SSH server hostname |
| `--ssh-port` | `SSH_PORT` | number | SSH server port (default: `22`) |
| `--ssh-user` | `SSH_USER` | string | SSH username |
| `--ssh-password` | `SSH_PASSWORD` | string | SSH password |
| `--ssh-key` | `SSH_KEY` | string | Path to SSH private key or base64-encoded key |
| `--ssh-passphrase` | `SSH_PASSPHRASE` | string | SSH key passphrase |
| `--ssh-agent` | `SSH_AUTH_SOCK` | string | SSH agent socket path |
| `--ssh-proxy-jump` | `SSH_PROXY_JUMP` | string | ProxyJump hosts |
| `--ssh-keepalive-interval` | `SSH_KEEPALIVE_INTERVAL` | number | Seconds between SSH keepalive packets (default: `0`, disabled) |
| `--ssh-keepalive-count-max` | `SSH_KEEPALIVE_COUNT_MAX` | number | Missed keepalive responses before the tunnel is dropped (default: `3`) |