DEV Community: Quincy Zhang

I Built an Open-Source SSH Workbench Because I Was Tired of Juggling 4 Tools to Manage My Servers

Quincy Zhang — Sat, 04 Jul 2026 09:46:21 +0000

Here's a familiar scene: you're debugging a production issue. You SSH in, tail the logs, spot an error. Now you need to upload a patched config file — so you open FileZilla, navigate six folders deep to find the right path. Then you want to ask AI what that cryptic error means — so you copy-paste terminal output into a browser tab. Meanwhile your SSH key passphrase is in yet another tool.

Four windows. One task.

That exact frustration is why I spent the last few months building Sageport — an all-in-one SSH workbench that combines terminal + SFTP + credential manager + AI assistant into a single desktop app. It's built with Tauri 2 and React, fully open source under GPL-3.0, and the binary is under 10MB.

The Pitch

Instead of four tools that don't talk to each other, imagine this:

Press ⌘ P, type a host name, hit Enter — you're connected
Press ⌘ J — a dual-pane file browser slides up, one side local, one side remote. Drag files across
Press ⌘ L — an AI panel opens. It can see your terminal output and propose fixes
Press ⌘ N — add a new host. Assign it any credential you've already saved. Done

Everything lives in a local SQLite database. No cloud account required. No vendor lock-in. Your data stays on your machine.

What Makes It Different

There are plenty of SSH clients out there. Here's why I built another one:

1. The AI Actually Has Access to Your Terminal

This isn't a chat sidebar copy-pasted into your workflow. Sageport's AI assistant is wired into the app via a tool-calling loop — it can list your open SSH sessions, read what's on screen, and propose commands. The key design choice: every remote command requires your explicit approval before it runs. No YOLO rm -rf from a hallucinating model.

You bring your own API key — Anthropic, OpenAI, or any compatible endpoint (Ollama, OpenRouter, etc.). Conversations are stored locally. No telemetry. We never see your data.

2. Five Sync Backends, All End-to-End Encrypted

Most tools either force you into their cloud (Termius) or don't sync at all. Sageport encrypts everything with Argon2id + AES-256-GCM and lets you pick where the ciphertext lives:

Provider	Best for
GitHub Gist (secret)	Developers — free, no setup if you have GitHub
Google Drive	Anyone with a Google account
OneDrive	Microsoft ecosystem
WebDAV	Self-hosted (Nextcloud, Synology NAS)
S3-compatible	Enterprise (AWS, MinIO, Cloudflare R2)

Only encrypted blobs ever leave your device. The passphrase never touches the network. If you lose your passphrase, the data is gone — and that's the point.

3. Credentials Are First-Class Citizens

In Sageport, credentials (called "identities") are separate from hosts. Create one SSH key, reuse it across 50 servers. The built-in key manager generates Ed25519, RSA, and ECDSA keys, imports existing keys in OpenSSH format, and supports passphrase protection. No more copy-pasting ~/.ssh/id_* files between machines.

4. It's a Real Desktop App, Not a Web View in Disguise

Built on Tauri 2 with a Rust backend. The SSH engine, SFTP handler, and crypto all run natively. The terminal uses xterm.js with GPU-accelerated WebGL rendering — smooth even under heavy output. Compare that to an Electron app eating 500MB of RAM just to hold an SSH session open.

The Stack (For the Curious)

Layer	Choice
Desktop shell	Tauri 2 (Rust)
UI	React 19 + TypeScript
Styling	Tailwind CSS 4
Terminal	xterm.js 6 + WebGL
SSH/SFTP	libssh2 (vendored OpenSSL)
Crypto	Argon2id + AES-256-GCM (pure Rust)
State	Zustand 5 + TanStack Query 5
Database	SQLite (via SQLx + migrations)

Everything is typed end-to-end, including the IPC layer between React and Rust — ~60 typed Tauri commands with compile-time safety.

Why GPL-3.0, Not MIT

I chose GPL-3.0 intentionally. This is a tool for developers, and I want every improvement to flow back to the community. If a company wants to fork it and build something proprietary on top, they can reach out. Otherwise, the code is yours to use, modify, and contribute to — forever.

What's on the Roadmap

Sageport is at v0.3.0 and I use it daily. It's stable, but there's a lot I want to build:

Terminal session sharing — share a read-only or interactive session via a link
RDP / VNC support — because not everything is SSH
Mobile companion app — view sessions and run snippets from your phone
Deeper AI context — let the assistant correlate logs across multiple hosts

Try It Out

Downloads for macOS, Windows, and Linux are on the releases page. The app auto-updates, so you'll always have the latest version.

# macOS: .dmg (Apple Silicon + Intel, universal)
# Windows: .msi / .exe
# Linux: .deb / .rpm / .AppImage

Quick setup —

⌘ N to add a host
⌘ P to connect via command palette
⌘ , for settings (AI keys, sync, themes)

Star on GitHub →

If you try Sageport and something breaks (or you have a feature idea), open an issue. I read every single one. This project exists because I scratched my own itch — odds are you have the same one.

Stop Teaching Your AI the Same Rules Every Session — mirrorai Mirrors Your Codebase Automatically

Quincy Zhang — Wed, 20 May 2026 02:25:41 +0000

You spent six months building a Vue admin panel. You have a wrapped request layer, a shared component library, a consistent page structure. Every file follows the same pattern.

Then you opened Cursor and asked it to add a new list page.

It imported axios directly. It wrote inline fetch logic. It named the component wrong. It ignored your entire architecture.

Sound familiar?

The Real Problem with AI Coding Assistants

The problem isn't that AI tools are bad — it's that every session starts from zero. The AI doesn't know your conventions. It doesn't know your wrappers. It invents its own style on the spot.

You end up spending more time correcting AI output than you saved generating it.

The fix isn't to write better prompts. The fix is to give the AI a permanent memory of how your project works.

Introducing mirrorai

mirrorai is a codebase-aware AI rules generator. It analyzes your existing code and produces rule files for the AI tools you actually use:

Output file	Tool
`CLAUDE.md` + `.claude/commands/`	Claude Code
`.cursorrules`	Cursor
`.windsurfrules`	Windsurf
`.github/copilot-instructions.md`	GitHub Copilot
`.clinerules`	Cline

One command to install. One /mirror-init to run. Your AI assistant finally understands your project.

How It Works

npx mirrorai install

This drops a single mirror-init.md into .claude/commands/. Then you run /mirror-init in your AI tool.

The AI does the real work — analyzing your project, not filling in some generic template:

Your project
   ↓
Detect language, framework, and stack from manifest files
   ↓
Scan business code and cluster files by unit type
   ↓
Score patterns: appears ≥ 3 times, ≥ 50 lines per file, ≥ 80% similarity
   ↓
Generate rule files + slash commands + scaffolding templates

The entire analysis runs inside your AI tool on your existing subscription. No API key. No cloud service. No data leaves your machine.

What Gets Generated

Rule files built from your real code

Not a generic "write clean code" checklist. The generated CLAUDE.md contains:

Your actual stack — exact frameworks, libraries, versions
Your directory layout and what each folder is for
Your core abstractions, and which layers must never be bypassed
Your infrastructure wrappers (HTTP client, auth, logging) with real usage examples
Your naming conventions, import order, and typing requirements
A reference file per pattern: "Before writing a new CRUD endpoint, read internal/handler/user.go"

Auto-execute rules that fire without a prompt

The real magic is the Auto-Execute Rules section in each generated file:

## Auto-Execute Rules

When the current task matches any of the patterns below,
immediately apply the corresponding rule without asking.

### New list page
- Trigger: "add a list page", "create a list view", "build a table page"
- Rule: use src/views/UserList.vue as reference; wrap requests with useRequest()
- Side effects: register the route in src/router/index.ts
- Scaffold first: npx mirrorai new new-list <name>

You describe the requirement in plain English. The AI recognizes the pattern and applies the right conventions — automatically, every single time, without you repeating yourself.

Zero-token scaffolding (opt-in)

If you opt in, mirrorai also generates a plopfile.js and Handlebars templates extracted from your actual code. Scaffold locally without spending a single token, then let the AI fill in only the business logic:

npx mirrorai new new-list LeaveApproval
# → generates the skeleton from your real project pattern
# → AI writes only the business logic on top

Works With Any Stack

mirrorai is fully language-agnostic. It adapts to whatever it finds:

Vue / React / Svelte / Angular frontends
Go / Rust / Python / Node.js backends
FastAPI, Django, NestJS, Spring Boot, Rails
Flutter mobile apps
CLI tools, data pipelines, GraphQL services

Re-running Is Safe

Run /mirror-init again after a major refactor. It detects existing files and asks what to do:

Regenerate everything
Refresh only existing files
Choose file by file

Files you wrote yourself — detected by the absence of a  marker — get a per-file prompt: merge, overwrite, or skip. Your content is never silently clobbered.

The Before / After

Before mirrorai:

You: Add a leave-of-absence approval flow.
AI:  *imports axios directly*
     *creates a new custom fetch utility*
     *names the component inconsistently*
     *forgets to register the route*

After mirrorai:

You: Add a leave-of-absence approval flow.
AI:  (recognizes the approval pattern from CLAUDE.md)
     → reads src/views/ApprovalList.vue as reference
     → uses useRequest() for all data fetching
     → names and structures the component correctly
     → registers the route in src/router/index.ts
     → suggests: npx mirrorai new new-approval LeaveApproval

Get Started in 30 Seconds

# Step 1: install the command into your project
npx mirrorai install

# Step 2: run this inside Claude Code, Cursor, Windsurf, or Cline
/mirror-init

Answer two questions — which AI tools to target, and whether to generate scaffolding — and mirrorai does the rest.

GitHub → github.com/joygqz/mirrorai

npm → npmjs.com/package/mirrorai

If this saves you from re-explaining your architecture one more time, a ⭐ on GitHub goes a long way. Issues and PRs are very welcome.