Endara Desktop

One endpoint for all your MCP servers. endara.ai

Add MCP servers, manage OAuth, browse tools — without ever opening a terminal.

Works with Claude Desktop, ChatGPT, Cursor, Windsurf, VS Code, Zed, Continue, and any MCP-compatible client.

What can you do?

• Visual endpoint dashboard — see every MCP server you've added with live health indicators, all in one place.
• Search tools across every connected server from a single ⌘K palette.
• Watch real-time logs stream from each endpoint as requests flow through.
• Manage OAuth flows end-to-end inside the app — no copy-pasting tokens between terminals.
• Single-click add server for STDIO, SSE, or HTTP MCP servers — paste a command or URL and you're done.

What is this?

Endara Desktop is a lightweight system tray application that wraps the Endara Relay — an MCP (Model Context Protocol) relay server that aggregates multiple MCP tool servers behind a single endpoint.

Instead of running the relay manually from a terminal, Endara Desktop gives you a single install that manages everything. It bundles the relay binary as a Tauri sidecar, automatically starts it on launch, monitors its health, restarts it if it crashes, and kills it cleanly on quit.

The app provides a visual interface for everything the relay exposes: endpoint health at a glance, a searchable tool browser, real-time log output, and configuration inspection — all from a compact tray-app UI inspired by Tailscale.

Download

macOS — Homebrew (recommended)

brew install --cask endara-ai/tap/endara

This installs the latest signed & notarized DMG from the endara-ai/homebrew-tap tap and registers the app for brew upgrade. Tauri's built-in updater also continues to work, so you'll get new versions whichever way you prefer.

Direct downloads

Or grab an installer directly from GitHub Releases — useful on Windows / Linux, or if you don't use Homebrew.

Or build from source if you prefer.

Quick Start

1. Install Endara Desktop using one of the options in Download above.
2. Launch the app — the tray icon appears in your menu bar and the bundled relay starts automatically on 127.0.0.1:9400.
3. Add a server — click the tray icon, choose Add server, and paste a STDIO command or an SSE / HTTP MCP server URL.
4. Connect your client — point Claude Desktop, Cursor, or any other MCP-compatible client at http://localhost:9400/mcp and your tools show up.

Features

• System tray integration — Runs in your menu bar / system tray, always available without cluttering your workspace
• Relay lifecycle management — Auto-starts the relay on launch, monitors it, auto-restarts on crash, kills on quit
• Endpoint dashboard — View all configured MCP server endpoints with live health indicators (🟢 healthy / 🟡 degraded / 🔴 down)
• Tool browser — Browse and search all tools exposed by each endpoint
• Real-time logs — Stream log output from each endpoint as it happens
• Config viewer — Inspect the current relay configuration
• Dark mode — Follows your system preference automatically
• Auto-updates — Checks GitHub Releases for new versions via the Tauri updater plugin

Keyboard shortcuts

Architecture

Endara Desktop is a Tauri 2 application with two layers:

┌─────────────────────────────────┐
│        SvelteKit Frontend       │
│   (Svelte 5 + Tailwind CSS 4)  │
│                                 │
│  Sidebar ←→ Detail Panel        │
│  (endpoints)  (tools/logs/cfg)  │
└────────────┬────────────────────┘
             │ Tauri IPC
┌────────────▼────────────────────┐
│        Tauri Backend (Rust)     │
│                                 │
│  Commands: start / stop /       │
│  restart / status               │
│                                 │
│  Sidecar ──→ endara-relay       │
│  (bundled binary)               │
└─────────────────────────────────┘

Backend (Rust): Manages the relay as a sidecar process — spawning, monitoring stdout/stderr, handling crashes with auto-restart, and clean shutdown on exit. Exposes a set of Tauri commands grouped roughly into:

• Relay lifecycle — start_relay, stop_relay, restart_relay, relay_status, get_sidecar_status, get_buffered_relay_logs, get_relay_port, set_relay_port.
• Management-API proxy — mgmt_api_request proxies HTTP-shaped /api/* calls from the SvelteKit frontend over the relay's per-user Unix socket / Named Pipe; get_mgmt_api_socket_path exposes the socket path for diagnostics.
• Config & endpoints — get_endpoint_config, add_endpoint, update_endpoint, remove_endpoint, get_config_path_display, set_js_execution_mode.
• Updates & autostart — get_update_channel, set_update_channel, check_for_update, download_and_install_update, show_update_notification, get_autostart, set_autostart, get_build_info.

Frontend (SvelteKit): Talks to the relay's management API to fetch endpoint status, tools, logs, and configuration. The UI is organized around a sidebar (endpoint list) + detail panel (per-endpoint tabs for tools, logs, config, auth) layout. Auxiliary components include onboarding, search palette, settings, an add-endpoint modal, and a unified tool catalog.

The Tauri webview runs under an explicit Content Security Policy (src-tauri/tauri.conf.json → app.security.csp) that restricts script, style, and connect sources to the app origin, IPC, and localhost endpoints. Management traffic from the SvelteKit frontend reaches the relay's /api/* through the mgmt_api_request Tauri command, which proxies HTTP semantics over the relay's per-user Unix-domain socket (Linux/macOS) or Named Pipe (Windows). MCP traffic flows over loopback TCP at the configured relay port.

Process model

In the standard desktop install, the desktop owns the relay. There is no separate background service — the relay's lifetime is bounded by the desktop's lifetime.

Endara Desktop (parent)
└── endara-relay (Tauri sidecar child)
    └── listens on 127.0.0.1:9400 (prod) / 9500 (dev)

• Spawn. On startup the desktop spawns the bundled endara-relay binary as a Tauri sidecar child process. The desktop passes --port (and the data dir / config path) on the command line; in dev it uses 9500, in production it uses 9400 by default.
• Listen. The relay binds to 127.0.0.1 only and accepts MCP traffic on the configured port. Other applications on the machine connect to it over loopback at that port.
• Shutdown. The relay dies with the desktop. On a clean quit the desktop sends SIGTERM to the sidecar; on a hard exit (force-quit, crash, logout) the OS reaps it with SIGKILL. There is no graceful-shutdown line emitted by the relay in the latter case — the last log entry is whatever it was doing when the parent died.
• Auto-start. If you enable "Launch at login" in Settings, the desktop registers a macOS LaunchAgent that re-launches the desktop (which then spawns the relay as its child). The LaunchAgent does not run the relay directly.

Bundled vs. brew-installed relay (do not mix)

There are two ways to get a relay on your machine, and they are mutually exclusive on the same port:

Pick one. If both are installed and both try to bind 127.0.0.1:9400, the second one to start will fail with EADDRINUSE. The desktop's bundled relay does not read or coordinate with a brew-installed endara-relay — they are separate binaries with separate config paths.

File locations (macOS)

• Bundled relay binary: /Applications/Endara Desktop.app/Contents/MacOS/endara-relay
• Auto-start LaunchAgent: ~/Library/LaunchAgents/Endara Desktop.plist (only present if "Launch at login" is enabled)
• Desktop log: ~/Library/Logs/ai.endara.desktop/Endara Desktop.log
• Relay log: ~/.endara/logs/relay.log.<YYYY-MM-DD> (rotated daily)
• Relay config: ~/.endara/config.toml

On Linux and Windows the same parent/child model applies; only the file paths differ (Tauri's standard log/config dirs for the ai.endara.desktop identifier, and no LaunchAgent — autostart uses the platform's native mechanism).

Development

Prerequisites

• Rust (stable)
• Node.js 20+
• Tauri CLI — cargo install tauri-cli --version "^2"
• The Endara Relay binary (see Sidecar setup)

Setup

# Clone the repository
git clone https://github.com/endara-ai/endara-desktop.git
cd endara-desktop

# Install frontend dependencies
npm install

# Start the dev server with hot-reload
cargo tauri dev

Sidecar setup

Tauri expects the relay binary at src-tauri/binaries/endara-relay-{target-triple} (e.g., endara-relay-aarch64-apple-darwin). A helper script is provided:

# Copy a locally-built relay binary into the correct sidecar location
./scripts/copy-sidecar.sh /path/to/endara-relay

Building for Production

cargo tauri build

This produces platform-specific installers in src-tauri/target/release/bundle/:

• macOS: .dmg in bundle/dmg/
• Windows: -setup.exe in bundle/nsis/, .msi in bundle/msi/
• Linux: .deb in bundle/deb/, .AppImage in bundle/appimage/

Project Structure

packages/desktop/
├── src/
│   ├── routes/                    # SvelteKit routes
│   │   ├── +layout.svelte         # Root layout
│   │   └── +page.svelte           # Main page
│   ├── lib/
│   │   ├── components/            # Svelte UI components (sidebar, detail panel, tabs, dialogs, modals, etc.)
│   │   ├── api.ts                 # API client for relay management
│   │   ├── stores.ts              # Svelte stores for app state
│   │   ├── types.ts               # TypeScript type definitions
│   │   └── mock.ts                # Mock data for development
│   ├── app.css                    # Global styles (Tailwind)
│   └── app.html                   # HTML shell
├── src-tauri/
│   ├── src/
│   │   ├── lib.rs                 # Tauri commands + relay sidecar lifecycle
│   │   ├── main.rs                # Entry point
│   │   ├── api_proxy.rs           # HTTP-over-UDS / Named-Pipe client for the relay's /api
│   │   └── webview_recovery.rs    # Webview crash detection + recovery
│   ├── tauri.conf.json            # Tauri config (bundling, updater, sidecar)
│   ├── capabilities/default.json  # Permissions (shell, updater)
│   ├── binaries/                  # Relay sidecar binary (not committed)
│   └── icons/                     # App icons for all platforms
├── scripts/
│   └── copy-sidecar.sh            # Helper to copy relay binary for bundling
├── package.json
└── LICENSE                        # Apache-2.0

Releasing

Releases are automated via GitHub Actions. The desktop release depends on Endara Relay — the relay must be released first so the desktop can download its binaries.

Release flow

1. Release the relay first — tag and push in endara-ai/endara-relay (e.g. v0.1.0)
2. Tag the desktop — git tag v0.1.0 && git push origin v0.1.0
3. The release workflow automatically:
   • Downloads the relay binary for each platform from the relay's GitHub Release
   • Places it at src-tauri/binaries/endara-relay-{target_triple}
   • Builds the Tauri app for macOS (x86_64 + aarch64), Windows, and Linux
   • Creates a GitHub Release with platform installers (.dmg, .msi, .deb, .AppImage)

You can pin to a specific relay version by triggering the workflow manually with the relay_version input (defaults to latest).

CI

On every push and PR, the CI workflow runs:

• Svelte check (type checking)
• Rust check (cargo check on the Tauri backend)
• PR title validation (conventional commits)

Contributing

Contributions are welcome! Here's how to get started:

1. Fork the repository
2. Create a feature branch (git checkout -b feat/my-feature)
3. Make your changes and test with cargo tauri dev
4. Commit your changes (git commit -m 'feat: add my feature')
5. Push to your fork (git push origin feat/my-feature)
6. Open a Pull Request

Please make sure npm run check passes before submitting.

Related Projects

• Endara Relay — The MCP relay server that Endara Desktop manages
• Endara — Project website
• endara-ai/homebrew-tap — Homebrew tap that ships the signed DMG and the headless relay CLI

License

Licensed under the Apache License, Version 2.0.

Copyright 2025–2026 Endara AI

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.