Catio

One native workbench for servers, databases, tunnels, monitoring, and AI.

Catio is an open-source operations and database client built with Rust + Tauri 2 + React. It brings SSH terminals, SFTP, remote monitoring, port forwarding, VNC/RDP entry points, a multi-engine database studio, asset discovery, Catio Agent, and MCP into one fast desktop app, with an optional browser-accessible Server mode for teams.

English · 简体中文

If you jump between terminals, SQL clients, tunnel scripts, monitoring tabs, AI chat, and spreadsheet exports every day, Catio is the attempt to make that whole workflow feel like one product instead of six glued-together tools.

Host workbench	Database workbench
Split terminals, command suggestions, multi-exec, and live CPU/memory/network/disk/GPU panels over SSH.	Schema tree, table preview, filtering, inline edits, import/export, and SQL tools in one database tab.

Catio Agent	Asset discovery
Ask about shell output, terminal errors, SQL, table schemas, and selected context without leaving the workbench.	Scan CIDR ranges, IP ranges, or hosts; fingerprint services; try credential/key dictionaries; import verified assets.

Data transfer	Server and security settings
Move table data between connections with column mapping, append/truncate/upsert modes, and progress feedback.	Local vault mode and Server mode both keep secrets out of plaintext connection profiles.

More screenshots

Agent asking data	Dark theme	Scan setup

Scan results	Agent model config	MCP settings

Database discovery	Host results	Grove theme

Theme settings

• SSH password and private-key auth, TOFU known hosts, ~/.ssh/config import, and ProxyJump/bastion support.
• xterm.js terminal with WebGL rendering, split panes, search, fit, shell history completion, and command broadcast across hosts.
• SFTP browser with upload/download progress, mkdir/rename/delete/touch, remote text editing, and browser upload/download endpoints in Server mode.
• Local shell, serial terminal, Telnet, Mosh, embedded VNC client, and native RDP client launch path.
• Local/remote/dynamic SSH forwarding, including SOCKS-style dynamic tunnels.
• Agentless monitoring over SSH exec: CPU, memory, network, disk, GPU, top processes, and OS detection.

• Query console built on CodeMirror 6 with dialect-aware highlighting, formatting, autocompletion, multi-statement editing, and result grids.
• Schema browser for tables/views/functions, table structure, object source, DDL helpers, ER relation metadata, and keyspace views.
• Editable table data with DML preview/apply, paging, WHERE/ORDER BY helpers, column visibility, filters, and safe destructive-action prompts.
• Import CSV/TSV/JSON/XLSX/XLSM/XLS into tables; export grids to XLSX; export database/schema SQL; run large SQL files with progress and cancellation.
• Transfer table data between connections with mapping and append/truncate/upsert modes.
• Query history and reusable snippets.
• Redis keyspace browsing/editing, Mongo shell-style paths, and Elasticsearch/rqlite HTTP-oriented access.

• Agent providers: local Ollama or OpenAI-compatible endpoints, with model fetch/test controls.
• The Agent can use current terminal output, selected text, active database schema/table context, and SQL snippets as prompt context.
• Desktop MCP server exposes connected hosts and databases over SSE with token auth, IP allowlist, and live logs.
• Server mode provides per-user MCP endpoints and tokens, so external agents can reach only that user's owned connections.

• Asset discovery accepts CIDR, IP ranges, single IPs, and hostnames.
• It fingerprints SSH/MySQL/PostgreSQL/Redis/MongoDB and can try credential dictionaries or SSH private keys.
• Results can be imported into the vault, grouped, or exported as CSV/JSON without exporting matched plaintext secrets.
• Local vault mode uses account verification and AES-GCM credential caching; Server mode stores per-user secrets encrypted with CATIO_MASTER_KEY.

Catio is one repository with two runtime heads.

Server mode is not a fork. The React UI and Rust core are shared, while src/services/transport.ts routes calls to Tauri, HTTP, or WebSocket depending on runtime.

• Server mode serves dist/, injects window.__CATIO_SERVER__=true, and stores data under CATIO_DATA.
• It supports login/bootstrap, user management, per-user stores, encrypted server-side secrets, SSH terminal streams, SFTP transfer endpoints, tunnels, monitoring, native database drivers, admin-only asset scans, and per-user MCP.
• Docker is the easiest deployment path. Binary deployment is supported, but the server still links Tauri/WebKit dependencies through the shared crate.
• JDBC engines are fully wired for desktop. The current Docker image does not bundle a JRE or the JDBC plugin path, so use native/protocol-compatible engines in Server mode unless you customize the image.
• Local-device features such as local terminal, serial, and external RDP client launch are desktop-first and may be hidden or limited in Server mode.

Read the full deployment guide: docs/server-mode-deployment.md.

Catio exposes 50+ selectable engine profiles. Some use native Rust drivers, some use wire-protocol compatibility, and long-tail engines go through the JDBC sidecar.

JDBC notes:

• Catio vendors src-tauri/resources/catio-jdbc-plugin.jar.
• End users still need a JRE/JDK 17+ for desktop JDBC usage.
• Proprietary database driver JARs are not redistributed. Put user-supplied drivers in CATIO_JDBC_DRIVERS_DIR.
• H2 is bundled for self-test paths.

• Node.js 18+ and npm
• Rust stable and the Tauri 2 prerequisites for your OS
• Optional: JDK 17+ and Maven, only when rebuilding the JDBC sidecar

npm ci
npm run tauri dev

npm run tauri build

Release bundles are emitted under src-tauri/target/release/bundle/.

npm run dev

This is useful for UI work and tests. Real SSH/database features require Tauri or Server mode.

DOCKER_BUILDKIT=1 docker build -t catio-server:local .

docker run -d \
  --name catio-server \
  --restart unless-stopped \
  -p 8787:8787 \
  -e CATIO_MASTER_KEY="CHANGE_ME_BASE64_32_BYTES" \
  -e CATIO_ADMIN_USER="admin" \
  -e CATIO_ADMIN_PASSWORD="CHANGE_ME_STRONG_PASSWORD" \
  -v catio-data:/app/data \
  catio-server:local

Open http://<server-ip>:8787. For production-like LAN usage, put it behind VPN, a gateway, or an HTTPS reverse proxy; do not expose an unaudited admin surface directly to the public internet.

catio/
├─ src/                         # React frontend: components, services, state, i18n, styles
│  ├─ components/
│  │  ├─ workbench/             # terminals, database panes, VNC, remote file editor
│  │  ├─ dbviews/               # SQL console, grids, import/export/transfer dialogs
│  │  ├─ panels/                # AI, SFTP, tunnels, monitor, snippets, history
│  │  ├─ scan/                  # asset discovery flow
│  │  └─ views/                 # home, vault, settings
│  ├─ services/                 # typed transport wrappers for Tauri/server/dev
│  └─ state/                    # connection stores, vault, preferences, conversations
├─ src-tauri/
│  ├─ src/
│  │  ├─ ssh/                   # SSH/SFTP/tunnels/monitor/multiexec
│  │  ├─ db/                    # DB commands, manager, drivers, import/export/transfer
│  │  ├─ scan/                  # range expansion, probes, concurrent login attempts
│  │  ├─ mcp/                   # shared MCP tool core
│  │  ├─ server*.rs             # Server mode HTTP/WS/MCP bridge
│  │  ├─ auth.rs                # Server users, sessions, per-user stores
│  │  └─ secrets.rs             # encrypted secret storage helpers
│  └─ jdbc-plugin/              # Java sidecar source and README
├─ docs/                        # plans, specs, deployment guide, screenshots
├─ deploy/test/                 # local DB integration-test compose stack
└─ scripts/                     # helper scripts for JDBC build and visual checks

# Frontend type-check + Vitest suite
npx tsc --noEmit
npm run test

# Rust library tests
cd src-tauri
cargo test --lib

Dual-mode CI also checks:

cargo check --manifest-path src-tauri/Cargo.toml --lib
cargo check --manifest-path src-tauri/Cargo.toml --bin catio
cargo check --manifest-path src-tauri/Cargo.toml --bin catio-server

Real-database integration tests are env-gated. Start dependencies with docker compose -f deploy/test/docker-compose.yml up --wait, then follow deploy/test/README.md.

Catio is especially good for contributors who care about developer tools, database clients, terminals, Rust/Tauri, or AI-assisted operations software.

High-impact contribution areas:

• database engine depth: SSL/TLS options, richer dialect metadata, JDBC polish, driver-specific UX
• terminal and remote ops: SFTP editing, VNC/RDP depth, tunnel UX, monitoring probes
• Server mode: Docker hardening, reverse-proxy docs, auditability, multi-user admin workflows
• AI/MCP: safer tool policies, better context selection, richer MCP tool coverage
• QA: targeted Vitest/Rust tests, visual checks, real database test fixtures

Local conventions:

• One logical change per commit.
• Keep changes surgical and match existing component/service/error patterns.
• Add user-visible text to both src/i18n/en.json and src/i18n/zh.json.
• Keep UI theme-aware by using CSS variables and existing design tokens.
• Never commit real passwords, private keys, production connection strings, downloaded proprietary JDBC drivers, or local logs.

If Catio matches a workflow you want to see in open source, a star, issue, bug report, benchmark, screenshot, or small PR all helps the project reach the next contributor.

Catio is released under the MIT License.

• Tauri for the lightweight desktop runtime.
• russh and Reach as references for SSH/SFTP/tunneling ideas.
• dbx as a reference for database-side patterns.
• xterm.js and CodeMirror for the terminal and editor foundations.
• Thanks to the Linux.do community for its discussions, feedback, and support.