Installation Guide
Installation Guide
Complete installation instructions for Kodachi security binaries on Debian-based Linux distributions. This guide covers system requirements, installation methods, dependency management, and verification procedures to get you up and running quickly and securely.
New: Kodachi Dashboard Included
The Kodachi Dashboard is now part of the binary packages! This modern desktop application (Tauri + Svelte) provides a unified interface for managing all Kodachi security services. After installation, launch it via the desktop shortcut or run kodachi-dashboard from the terminal.
Documentation Navigation
Looking for more guides?
- User Guides - Comprehensive guides for all Kodachi binaries
- CLI Reference - Complete command-line reference
Getting Started with Kodachi Binaries
Production Release
These binaries are now production-ready and validated across Debian 12/13, Ubuntu 22.04+, and other modern distributions. The workflows, auth model, and security hardening have passed the same QA cycle that ships with Kodachi Terminal Server.
Best Practice: New users can still begin inside a virtual machine to learn the commands, then migrate to primary systems once comfortable.
Need help or want to report an issue?
- Join my Discord community for real-time support and discussions
- Submit detailed feedback directly to my inbox via my contact form
Community feedback remains vital—thank you for helping keep Kodachi strong.
System Requirements
Minimum Requirements
| Component | Requirement | Recommended |
|---|---|---|
| Operating System | Linux (Debian-based) | Ubuntu 22.04+ / Debian 12+ / Debian 13 (Trixie) |
| Architecture | x86_64 | x86_64 |
| Memory (RAM) | 2GB minimum | 4GB or higher |
| Storage Space | 500MB for binaries | 1GB for full installation |
| Linux Kernel | 4.15+ | 5.15+ (LTS) |
Compatibility & Testing Recommendations
Verified Systems: These binaries have been extensively tested on Debian 12 (Bookworm) and Debian 13 (Trixie/Testing) and work without any issues on x86_64 architecture.
Cross-Distribution Compatibility: The Rust binaries are highly portable and will work on most modern Linux distributions (Ubuntu, Fedora, Arch, etc.). If you encounter any difficulties, they typically stem from system package dependencies, not from the binaries themselves.
Recommended Testing Environment: For the most reliable testing experience, I recommend:
- Download the latest Debian 13 live ISO (curl is already included)
- Install it fresh (physical or virtual machine)
- Run both installation scripts as documented below
Note for Minimal Desktop Installations: If you're using a minimal desktop ISO (not the live ISO), you need to install curl first:
The dependency installation script will automatically install required packages like procps (for pgrep/pkill) and psmisc (for killall).
Quick Installation First Release: 03 October 2025 9.0.1 | Binaries last updated 23 March 2026 - night build #141
Two-Step Installation Process
Installation requires two steps
Step 1: Install binaries (may request sudo for /opt/kodachi/) Step 2: Install system dependencies (requires sudo)
Step 1: Install Binaries
Package SHA256 Checksum:
The installer verifies both package signature (.sig) and checksum (.sha256) automatically before extraction.
Default installation to /opt/kodachi/dashboard/hooks
Step 2: Install Dependencies (Requires Sudo)
Install recommended packages
Updating an Existing Installation?
If you're running this to update your existing installation, you must stop Permission Guard first to avoid file conflicts.
**Quick Methods:**
1. **Log out (simplest - recommended):**
```bash
sudo online-auth logout
```
2. **Stop Permission Guard manually:**
```bash
sudo permission-guard --stop-daemon
```
For detailed update instructions, see the [Updates](#updates) section below.
Installation Options
Installation Paths
The installer supports multiple installation locations:
| Option | Path | Command |
|---|---|---|
| Default | /opt/kodachi/dashboard/hooks |
curl -sSL ... \| bash |
| Desktop | ~/Desktop/dashboard/hooks |
curl -sSL ... \| bash -s -- --desktop |
| Custom | User-specified | curl -sSL ... \| bash -s -- --path /custom/path |
Additional Installation Parameters
Alternative Installation Paths
# Install to Desktop
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --desktop
# Install to custom path
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --path /srv/kodachi
Version-Specific Installation
# Install specific version
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --version 9.0.1
# Install without modifying ~/.bashrc PATH
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --skip-path
Dependency Installation Options
# Full installation (default mode, auto-confirm prompts)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash
# Explicit full + auto mode (same behavior)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --full --auto
# Interactive mode (prompts category-by-category)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh -o kodachi-deps-install.sh && sudo bash kodachi-deps-install.sh --interactive
# Minimal mode (essential + network + privacy/DNS + monitoring + proxy tools)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --minimal
# Full mode (all major categories; GUI depends on desktop detection)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --full
# Install proxy tools only (v2ray, xray, hysteria2, mieru)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --proxy-only
# Disable auto-confirmation prompts
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --no-auto
# Force GUI packages on headless systems
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --force-gui
# Skip GUI packages even if desktop is detected
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --skip-gui
# Install with optional Kicksecure RAM wipe (if you prefer it over Kodachi's built-in RAM wipe)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --full --force-kicksecure-ramwipe
# Verbose output for debugging
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --verbose
Manual Binary Installation
# Download binaries archive
wget https://www.kodachi.cloud/apps/os/install/kodachi-binaries-v9.0.1.tar.gz
# Extract archive to temporary directory
tar -xzf kodachi-binaries-v9.0.1.tar.gz
cd kodachi-binaries-v9.0.1
# Create directory structure used by the installer
mkdir -p /opt/kodachi/dashboard/hooks/{config/signkeys,config/profiles,icons,logs,tmp,results/signatures,backups,others,sounds,flags,licenses,binaries-update-scripts,models,data}
# Copy package contents
cp binaries/* /opt/kodachi/dashboard/hooks/
cp -r config/* /opt/kodachi/dashboard/hooks/config/
cp -r signatures/* /opt/kodachi/dashboard/hooks/results/signatures/
cp -r sounds/* /opt/kodachi/dashboard/hooks/sounds/
cp -r flags/* /opt/kodachi/dashboard/hooks/flags/
cp -r licenses/* /opt/kodachi/dashboard/hooks/licenses/ 2>/dev/null || true
cp -r binaries-update-scripts/* /opt/kodachi/dashboard/hooks/binaries-update-scripts/ 2>/dev/null || true
cp -r models/* /opt/kodachi/dashboard/hooks/models/ 2>/dev/null || true
# Ensure all top-level binaries are executable
find /opt/kodachi/dashboard/hooks -maxdepth 1 -type f -exec chmod 755 {} +
# Install system dependencies
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash
System Dependencies
The kodachi-deps-install.sh script installs packages grouped by category:
Package Categories (from kodachi-deps-install.sh)
Automatic Package Handling
Special handling performed by the installer:
The installation script automatically handles these packages:
- **Pi-hole** - Installed via official installer script (auto in non-interactive mode; prompted in interactive mode)
- **shadowsocks-v2ray-plugin** - Downloaded from GitHub (v1.3.2) if contrib/non-free not available
- **v2ray** - Requires contrib/non-free repos or manual installation from GitHub
- **dnscrypt-proxy** - Downloaded from GitHub (v2.1.15) with apt fallback
- **qrencode** - Compiled from GitHub source (v4.1.1) with apt fallback
- **resolvconf/openresolv** - The installer automatically handles compatibility between resolvconf and openresolv. If resolvconf conflicts with systemd-resolved, openresolv will be installed as an alternative to provide the resolvconf command for VPN tools
- **systemd-resolved** - Modern DNS resolver with caching (Debian 12+ separate package). Automatically configured to work alongside dnscrypt-proxy/Pi-hole by disabling the stub listener when other DNS services are active to avoid port 53 conflicts
- **kloak** - Keystroke anonymization tool compiled from source (v0.2)
- **grub-common / grub2-common / grub-pc** - GRUB bootloader tools automatically detected and installed for health-control RAM wipe support. The installer detects which variant is needed (GRUB2 vs legacy). Not required for RAM wipe to function, but enables `init_on_free=1` kernel parameter for additional security. On live systems or non-GRUB bootloaders, the installer will skip these packages with an informational message
RAM Wipe Functionality
Kodachi has built-in RAM wipe via health-control memory-wipe command. This is installed by default with the binaries.
**Optional:** If you want to install Kicksecure's ram-wipe package instead, use the `--force-kicksecure-ramwipe` parameter:
```bash
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash -s -- --full --force-kicksecure-ramwipe
```
The script will inform you during installation if repositories are missing and handle fallback installation automatically.
Installation Modes
| Mode | Command | Packages Installed |
|---|---|---|
| Full (Default) | curl -sSL .../kodachi-deps-install.sh | sudo bash |
Essential, Network, Privacy, Security, Advanced, Monitoring, Contrib, Proxy Tools (+ GUI if desktop is detected) |
| Minimal | curl -sSL .../kodachi-deps-install.sh | sudo bash -s -- --minimal |
Essential, Network, Privacy, Monitoring, Contrib, Proxy Tools (+ Pi-hole and DNS tooling) |
| Interactive | curl -sSL .../kodachi-deps-install.sh -o kodachi-deps-install.sh && sudo bash kodachi-deps-install.sh --interactive |
Prompts for each category; same package sources as full mode but user-selected |
| Proxy Only | curl -sSL .../kodachi-deps-install.sh | sudo bash -s -- --proxy-only |
v2ray, xray, mieru v3.27.0, hysteria2 v2.7.0 |
Configuration
Post-Installation Setup
# The installer creates all necessary directories
# Configuration is stored in /opt/kodachi/dashboard/hooks/config
# For system-wide integration (optional)
cd /opt/kodachi/dashboard/hooks && sudo ./global-launcher deploy
Directory Structure
Verification & Security
Verifying Installation
# Verify all packaged binaries are installed and executable
KODACHI_HOME="/opt/kodachi/dashboard/hooks"
echo "Checking binaries..."
BINARIES=(
deps-checker dns-leak dns-switch global-launcher health-control integrity-check ip-fetch
kodachi-dashboard conky-status logs-hook online-auth online-info-switch oniux permission-guard
routing-switch tor-switch tun2socks-linux-amd64 workflow-manager
ai-cmd ai-trainer ai-learner ai-admin ai-monitor ai-scheduler ai-discovery
ai-gateway kodachi-claw zeroclaw
)
for binary in "${BINARIES[@]}"; do
if [ -x "$KODACHI_HOME/$binary" ]; then
version=$("$KODACHI_HOME/$binary" --version 2>/dev/null | head -1 || true)
[ -n "$version" ] && echo "[OK] $binary: $version" || echo "[OK] $binary: installed"
else
echo "[MISSING] $binary: not installed or not executable"
fi
done
# Verify configuration files are present
echo -e "\nChecking configuration files..."
[ -f "$KODACHI_HOME/config/dns-database.json" ] && echo "[OK] DNS database present" || echo "[MISSING] DNS database missing"
[ -d "$KODACHI_HOME/config/signkeys" ] && echo "[OK] Signing keys directory present" || echo "[MISSING] Signing keys missing"
[ -f "$KODACHI_HOME/config/os-info.yaml" ] && echo "[OK] OS info file present" || echo "[MISSING] OS info missing"
# Verify sound files are present
echo -e "\nChecking notification sounds..."
for sound in alert.wav warning.wav success.wav error.wav; do
[ -f "$KODACHI_HOME/sounds/$sound" ] && echo "[OK] $sound present" || echo "[MISSING] $sound missing"
done
# Verify flag icons are present
echo -e "\nChecking flag icons..."
[ -d "$KODACHI_HOME/flags" ] && echo "[OK] Flags directory present ($(ls -1 $KODACHI_HOME/flags/*.png 2>/dev/null | wc -l) flags)" || echo "[MISSING] Flags directory missing"
# Verify signatures are present
echo -e "\nChecking binary signatures..."
sig_count=$(ls -1 $KODACHI_HOME/results/signatures/*.sig 2>/dev/null | wc -l)
echo "Found $sig_count binary signatures"
# Check directory permissions
echo -e "\nChecking directory permissions..."
[ -w "$KODACHI_HOME/logs" ] && echo "[OK] logs/ is writable" || echo "[WARN] logs/ is not writable"
[ -w "$KODACHI_HOME/tmp" ] && echo "[OK] tmp/ is writable" || echo "[WARN] tmp/ is not writable"
Signature Verification
The installer automatically verifies binaries against:
| Verification Type | Method | Source |
|---|---|---|
| Package Signature | RSA signature check with OpenSSL | kodachi-binaries-*.tar.gz.sig |
| Package Checksum | SHA256 checksum verification | kodachi-binaries-*.tar.gz.sha256 |
| Per-Binary Signature Check | Signature check for each extracted file | signatures/<binary>_v*.sig |
Manual Package Verification
To manually verify a downloaded package before installation:
# Download the binary package
wget https://www.kodachi.cloud/apps/os/install/kodachi-binaries-v9.0.1.tar.gz
# Download signature and public key
wget https://www.kodachi.cloud/apps/os/install/kodachi-binaries-v9.0.1.tar.gz.sig
wget https://www.kodachi.cloud/apps/os/install/public_key_v9.0.1.pem
# Verify package signature
openssl dgst -sha256 -verify public_key_v9.0.1.pem \
-signature kodachi-binaries-v9.0.1.tar.gz.sig \
kodachi-binaries-v9.0.1.tar.gz
# Verify package checksum
wget https://www.kodachi.cloud/apps/os/install/kodachi-binaries-v9.0.1.tar.gz.sha256
sha256sum -c kodachi-binaries-v9.0.1.tar.gz.sha256
Verifying Installed Binaries
Check File Integrity (Hashes)
# Verify file hashes for all installed binaries
integrity-check check-integrity
# → Shows pass/fail status for each file
Check Binary Signatures
# Verify signatures for all installed binaries
integrity-check check-signatures
# → Validates RSA signatures against public key
Check Version Information
# Check version consistency across binaries
integrity-check check-version
# → Version comparison results
Run All Verification Checks
# Run comprehensive verification (integrity, signatures, version)
integrity-check check-all
# → Complete verification report
Manual Signature Verification
# Or manually verify individual binary signatures
cd /opt/kodachi/dashboard/hooks
for sig in results/signatures/*.sig; do
binary=$(basename "$sig" .sig | cut -d'_' -f1)
if [ -f "$binary" ]; then
openssl dgst -sha256 -verify config/signkeys/public_key_v9.0.1.pem \
-signature "$sig" "$binary"
fi
done
Docker Installation
Default Installation Path
Both Docker and regular installations now default to /opt/kodachi/dashboard/hooks.
- **Why `/opt/kodachi`?**: Follows the Filesystem Hierarchy Standard (FHS) where `/opt` is the standard location for add-on application software packages. This provides a single canonical location regardless of install method.
- **Automatic setup**: The binary installer requests sudo once to create `/opt/kodachi/` and set ownership to the current user. No root access is needed after that.
- **Custom paths**: The `--path` parameter lets you override to a custom location if needed.
Using Docker
Essential Package Requirements
The dependency installation script requires procps (for pgrep/pkill) and psmisc (for killall) packages to function properly. These must be installed before running the dependency script.
FROM debian:trixie-slim
# Set environment to avoid interactive prompts
ENV DEBIAN_FRONTEND=noninteractive
# Remove default sources and add contrib/non-free repositories
RUN rm -f /etc/apt/sources.list.d/debian.sources && \
echo "deb http://deb.debian.org/debian/ trixie main contrib non-free non-free-firmware" > /etc/apt/sources.list && \
echo "deb http://security.debian.org/debian-security trixie-security main contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
echo "deb http://deb.debian.org/debian/ trixie-updates main contrib non-free non-free-firmware" >> /etc/apt/sources.list
# Install apt-utils first to avoid debconf warnings
RUN apt-get update && apt-get install -y --no-install-recommends \
apt-utils \
&& rm -rf /var/lib/apt/lists/*
# Configure debconf to prevent resolvconf installation issues in Docker
RUN apt-get update && apt-get install -y debconf-utils && \
echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections && \
echo "resolvconf resolvconf/linkify-resolvconf boolean false" | debconf-set-selections && \
rm -rf /var/lib/apt/lists/*
# Install essential dependencies that the scripts need
RUN apt-get update && apt-get install -y \
curl wget openssl ca-certificates sudo \
procps psmisc \
coreutils findutils grep \
&& rm -rf /var/lib/apt/lists/*
# Install Kodachi binaries (defaults to /opt/kodachi/dashboard/hooks)
RUN curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash
# Install system dependencies using the official script (requires sudo)
RUN curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash
# Add to PATH
ENV PATH="/opt/kodachi/dashboard/hooks:${PATH}"
# Set entrypoint
ENTRYPOINT ["health-control"]
Docker Compose
services:
kodachi:
image: kodachi/security-binaries:v9.0.1
privileged: true
network_mode: host
volumes:
- ./config:/opt/kodachi/dashboard/hooks/config
- ./logs:/opt/kodachi/dashboard/hooks/logs
command: ["net-check"]
Building and Running
# Build the Docker image
docker build -t kodachi-binaries:v9.0.1 .
# Run a container
docker run --rm --privileged kodachi-binaries:v9.0.1 net-check
# Or with docker compose (v2)
docker compose up
Updates
Manual Updates
To update to the latest version:
# Step 1: Update binaries (no sudo required)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash
# Step 2: Update dependencies (requires sudo)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash
# Or specify a specific version for binaries
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --version 9.0.1
Updating Existing Installation
Important: Stop Permission Guard Before Updating
The permission-guard service must be stopped to avoid file permission conflicts during updates.
**Choose one of these methods:**
1. **Log out, run the update scripts, then log back in** (simplest method - recommended)
2. **Stop the daemon manually:**
```bash
sudo permission-guard --stop-daemon
```
**OR**
```bash
sudo online-auth disable-permission-guard
```
**Verify permission-guard is disabled:**
```bash
sudo permission-guard --daemon-status
# OR
sudo online-auth permission-guard-status
```
Once permission-guard is stopped, run both update scripts:
# Step 1: Update binaries (no sudo required)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash
# Step 2: Update dependencies (requires sudo)
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-deps-install.sh | sudo bash
# Step 3: Verify the update
integrity-check check-version
Alternative Installation Paths
If you installed to a custom location (e.g., --desktop or --path), make sure to use the correct path:
# Default/canonical installation path
sudo /opt/kodachi/dashboard/hooks/permission-guard --daemon-status
# For custom --path installation
sudo /custom/path/permission-guard --daemon-status
Version Check
Note: Automatic updates are planned for future releases
Uninstallation
Complete Removal
# Remove the entire hooks directory
rm -rf /opt/kodachi/dashboard/hooks
# Or if installed elsewhere
rm -rf ~/Desktop/dashboard/hooks
rm -rf /custom/path
Selective Removal
# Keep configuration but remove binaries
cd /opt/kodachi/dashboard/hooks
rm -f deps-checker dns-leak dns-switch global-launcher health-control integrity-check ip-fetch
rm -f kodachi-dashboard conky-status logs-hook online-auth online-info-switch oniux permission-guard
rm -f routing-switch tor-switch tun2socks-linux-amd64 workflow-manager
rm -f ai-cmd ai-trainer ai-learner ai-admin ai-monitor ai-scheduler ai-discovery
rm -f ai-gateway kodachi-claw zeroclaw
Troubleshooting
Common Issues
Tip: After installation, run
integrity-check generateto create baseline hashes for system integrity monitoring.
Getting Started Quick Reference
Get up and running with Kodachi security binaries in minutes.
One-Line Installer (Recommended)
# Default installation to /opt/kodachi/dashboard/hooks
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash
# Install to Desktop
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --desktop
# Custom installation path
curl -sSL https://www.kodachi.cloud/apps/os/install/kodachi-binary-install.sh | bash -s -- --path /custom/path
Post-Installation Setup
# Add binaries to PATH
export PATH="/opt/kodachi/dashboard/hooks:$PATH"
# Or source the environment script
source /opt/kodachi/dashboard/hooks/kodachi-env.sh
# Verify installation
ip-fetch --version
tor-switch --version
health-control --version
Quick Troubleshooting
Connection Issues
# Recover routing/network issues
sudo routing-switch recover
# Recover internet connectivity
sudo health-control recover-internet --force
# Reset DNS to defaults
sudo dns-switch restore-default
Authentication Problems
# Re-authenticate
sudo online-auth logout
sudo online-auth authenticate
# For long sessions, use --relogin for automatic reconnection
sudo online-auth authenticate --relogin
# Check if blocked
online-auth check-if-blocked
Binary Overview
Network & Anonymity
- tor-switch - Advanced Tor network orchestration (107 commands)
- routing-switch - Multi-protocol routing engine (12 protocols)
- ip-fetch - Secure IP geolocation with verification
- dns-switch - DNS management with 50+ resolvers
- dns-leak - Real-time DNS leak detection
Security & Protection
- health-control - System health and emergency controls
- integrity-check - File integrity verification
- permission-guard - Permission management and monitoring
System Management
- online-auth - Authentication services with heartbeat
- logs-hook - Centralized logging system
- deps-checker - Dependency verification
- global-launcher - System-wide binary integration
- oniux - Mount and user isolation
- online-info-switch - System information management
- conky-status - Conky details (legacy
conky-details) telemetry gateway
AI & Intelligence
- ai-cmd - Natural language command interface
- ai-gateway - Unified agent command gateway and policy firewall
- ai-trainer - ML model training and validation
- ai-learner - Learning orchestration and analysis
- ai-admin - Database management and diagnostics
- ai-discovery - Binary watcher and auto-indexer
- ai-scheduler - Cron-based task scheduler
- ai-monitor - Proactive system monitoring
- kodachi-claw - Anonymous AI agent runtime with embedded Tor
- zeroclaw - Upstream-compatible lightweight AI agent runtime (agent profile)
Next Steps
- Explore Network Tools: Review the Network Tools Overview for advanced features.
- Configure Security: Set up Health Control panic modes.
- Test Your Setup: Use DNS Leak to verify privacy.
- Learn Commands: Run any binary with
--helpor--examplesflags.
Quick Reference
# Help and examples for any binary
tor-switch --help
tor-switch --examples
tor-switch --version
# JSON output for automation
ip-fetch fetch --json-human
health-control net-check --json-human
dns-leak test --json-human
# Human-readable JSON output
ip-fetch fetch --json-human
tor-switch tor-status --json-human
routing-switch list-protocols --json-human