runelay
OfficialConnects a GitHub account once via one-click OAuth so every agent shares the same GitHub tools through a single MCP endpoint, with optional "Sign in with GitHub" support on the panel.
Connects a Linear account once via one-click OAuth so every agent shares the same Linear tools through a single MCP endpoint; the connection is stored encrypted on your own server and used by all agents.
Connects a Notion account once via one-click OAuth so every agent shares the same Notion tools and context through a single MCP endpoint.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
✨ Why
Every agent lives on its own island. You log into Linear four times, copy the same skill to four folders, and teach Claude a rule that Codex never hears about.
runelay is the bridge: one MCP endpoint, on your server, in front of every account, skill and memory. It runs no model. Your agent thinks; runelay is where it finds tools and context.
flowchart LR
subgraph A[" Your agents "]
CC[Claude Code]
CX[Codex]
CU[Cursor]
GK[Grok]
end
R((runelay))
subgraph B[" Your stuff "]
AC[Linear · GitHub · Notion · any OpenAPI]
SK[Skills]
ME[Memory]
end
CC & CX & CU & GK -- "Bearer rnl_…" --> R
R --> AC & SK & ME
classDef hub fill:#f0a050,stroke:#f0a050,color:#111,font-weight:bold
class R hubRelated MCP server: Daemoon
🧩 What you get
🔌 Connect once | ~25 curated MCP servers with one-click OAuth, plus any remote MCP, local MCP or OpenAPI spec. |
🧠 Shared memory | Notes linked with |
📚 Skills that travel | Your |
📥 Import in one go | Memories, skills and instructions from Claude Code, Codex, Cursor, Grok, Gemini and OpenCode. |
🔑 One key per agent | Revoke one without touching the others. Every call audited. |
🏠 Yours | One container, SQLite, no third-party services. MIT. |
🚀 Quick start
curl -fsSL bot.runelay.com/install | shThat is it. The script creates ~/runelay, writes a .env with a fresh RUNELAY_SECRET, pulls the image and starts it on 127.0.0.1:4312. Open the link it prints, create your account and follow Acesso → Configurar agentes.
Migrate in one command
On the computer where your agents live:
curl -fsSL bot.runelay.com/cli | sh
runelay migratemigrate logs in through the browser if needed, then reads Claude Code, Codex, Cursor, Grok, Gemini and OpenCode: MCP servers, memories, skills and global instructions. It shows a summary per agent, asks once and sends everything.
Comes connected: OAuth accounts the agent already logged into. runelay reads the tokens Grok keeps in
~/.grok/mcp_credentials.jsonand, on macOS, the ones Codex and Claude Code keep in the Keychain (macOS may ask for permission). Servers that authenticate with headers come connected too.Asks for login: everything else, including Cursor accounts (Cursor encrypts its tokens). At the end the CLI opens
/connectors/reconnect, a queue that walks you through the remaining logins one tab at a time.Stays on the agent: local command servers (stdio). Add them from the panel if you want them in runelay.
Token rotation: many providers rotate the refresh token on use. Once runelay refreshes it, the old agent may ask you to log in again. Run with
--replace(or answert) to remove the migrated MCPs from the agents and leave only runelay.
runelay migrate --yes skips the question (required without a terminal). Tokens are sent only to your server and stored encrypted.
Options go in front of sh:
curl -fsSL bot.runelay.com/install \
| PUBLIC_URL=https://runelay.example.com RUNELAY_DIR=/opt/runelay RUNELAY_VERSION=v0.1.0 shUpdate: cd ~/runelay && docker compose pull && docker compose up -d
services:
runelay:
image: ghcr.io/runelay/runelay:latest
restart: unless-stopped
env_file: .env
ports:
- "127.0.0.1:4312:4312"
volumes:
- ./data:/dataPUBLIC_URL=https://runelay.example.com # the URL people and agents use
RUNELAY_SECRET=$(openssl rand -hex 32) # encrypts connections and API keys; back it up
ALLOW_SIGNUP=false # first signup becomes the owner, then signups closegit clone https://github.com/runelay/runelay.git && cd runelay
cp .env.example .env # set PUBLIC_URL and RUNELAY_SECRET
docker compose up -d --build
bun run devis only for working on runelay itself. To run it, use the image.
Caddy
runelay.example.com {
reverse_proxy 127.0.0.1:4312
}Cloudflare Tunnel
ingress:
- hostname: runelay.example.com
service: http://127.0.0.1:4312
- service: http_status:404OAuth callbacks go to PUBLIC_URL/v1/oauth/callback, so PUBLIC_URL must be the public address.
Variable | Default | Description |
|
| Public URL of the panel and API. Used for OAuth callbacks and cookies. |
| required, 32+ chars | Encrypts connection configs, OAuth tokens and recoverable API keys. Losing it means reconnecting everything. |
| generated | One-time token required to create the first account. |
|
| Keep signups open after the first account. |
|
| Enables the sandboxed |
|
| Enables local MCP servers by command. See Security. |
|
| Allows connections to private network addresses. |
|
| Requests per minute allowed for each API key. |
| empty | Enables "Sign in with GitHub" on the panel. |
|
| Where the SQLite database lives. |
|
| Where the server listens. |
🤖 Connect your agents
In the panel, open Acesso → Configurar agentes. The guide walks you through connecting accounts, creating a key and wiring each client.
Or paste the config yourself (replace the URL and key):
Claude Code
claude mcp add --scope user --transport http runelay https://runelay.example.com/v1/mcp \
--header "Authorization: Bearer rnl_..."Codex (~/.codex/config.toml)
[mcp_servers.runelay]
url = "https://runelay.example.com/v1/mcp"
http_headers = { Authorization = "Bearer rnl_..." }Grok (~/.grok/config.toml)
[mcp_servers.runelay]
url = "https://runelay.example.com/v1/mcp"
headers = { Authorization = "Bearer rnl_..." }Cursor (~/.cursor/mcp.json)
{ "mcpServers": { "runelay": { "url": "https://runelay.example.com/v1/mcp", "headers": { "Authorization": "Bearer rnl_..." } } } }All of them at once with the CLI (see below): runelay login, then runelay connect.
📥 Bring your context
The runelay CLI runs on your computer, because that is where your agents keep their files. Install it, log in through the browser, done: no env vars, no keys to copy.
curl -fsSL bot.runelay.com/cli | sh
runelay login # finds your server, opens the browser, saves this computer's key
runelay status # server, organization and what is stored in it
runelay push # memories, skills and global instructions from every installed agent
runelay pull # brief into CLAUDE.md and AGENTS.md, new skills into ~/.claude/skills
runelay sync # push, then pull
runelay connect # registers the runelay MCP in Claude Code, Codex, Cursor and Grok
runelay import # MCP servers from Claude, Codex, Grok and Cursor configs become connections
runelay logout # revokes this computer's key and clears the configrunelay login looks for PUBLIC_URL in ~/runelay/.env (what the installer writes), then for http://localhost:4312, and asks before using what it found. You can also pass the address: runelay login https://runelay.example.com. The browser shows a code: check it matches the terminal and approve. The key shows up in the panel as CLI <device> and is saved in ~/.config/runelay/config.json (mode 600, XDG_CONFIG_HOME respected).
The installer puts the binary in ~/.runelay/bin (change it with RUNELAY_INSTALL_DIR, pin a release with RUNELAY_VERSION=v0.2.0) and adds it to your shell PATH.
CI / env vars. RUNELAY_URL and RUNELAY_API_KEY override the saved config, so a pipeline can run runelay push with a key created in the panel. Inside a clone of this repo, bun run import-context, sync-context, install-clients and import still work and map to push, pull, connect and import.
runelay push reads:
Agent | Skills | Memory and instructions |
Claude Code |
|
|
Agents (universal) |
| |
Codex |
|
|
Cursor |
| |
Grok |
|
|
Gemini |
|
|
OpenCode |
|
|
Duplicates are merged (first one wins). Memories listed under ## Regras de ouro in a MEMORY.md, and global instruction files, come in pinned.
runelay pull only touches the block between <!-- runelay:start --> and <!-- runelay:end -->. Everything else in your files stays as it is. The brief tells agents to save new facts with write_memory, so memory flows back to runelay instead of local files.
Enabled skills you do not have in any agent folder are written to ~/.claude/skills/<slug>/ with a .runelay marker. Later pulls update only marked folders and push skips them. A folder without the marker is yours and is never overwritten.
📖 Reference
Tool | What it does |
| Every connection with status and tool count. |
| Search tools across all connections ( |
| Call one tool with arguments. |
| Run JavaScript that chains tools inside a WebAssembly sandbox: |
| Full-text search across memories and skills. |
| Read a memory, or create and update one (versioned). |
| Read a skill and its files. |
Everything the panel does goes through a versioned JSON API. Every response is { data, error }.
Method | Route | Auth |
|
| better-auth (email and password, GitHub) |
GET |
| session |
GET, POST |
| session |
GET, POST |
| session |
POST, GET |
| public, rate limited |
GET, POST |
| session |
GET, DELETE |
| API key (status also session) |
GET, POST |
| session or API key |
GET, PATCH, DELETE |
| session or API key |
GET, POST |
| session or API key |
GET, POST, PATCH, DELETE |
| session or API key |
GET, POST, PATCH, DELETE |
| session or API key |
GET |
| session or API key |
GET |
| session or API key |
|
| API key |
runelay holds credentials for every account you connect, so it is locked down by default.
First access. While no account exists, signing up needs a one-time setup token. The installer generates it and prints the link (/login?mode=signup&token=…). Without RUNELAY_SETUP_TOKEN in .env, the server makes one at startup and prints the link in docker compose logs. After the first account, signups close (unless ALLOW_SIGNUP=true).
Credentials.
Connection configs, OAuth tokens and recoverable API keys are encrypted with AES-256-GCM using
RUNELAY_SECRET.Agents never receive credentials: requests made with an API key, and the
list_connectionstool, see headers and env values as••••••.Importing a client config through the API never expands
${VARS}from the server environment.API keys belong to one organization. Revealing a key needs a panel session, never an API key.
Risky capabilities.
Variable | Default | What it unlocks |
|
| The |
|
| Local MCP servers ( |
|
| Connections to private, loopback, link-local and CGNAT (100.64.0.0/10) addresses (SSRF protection: cloud metadata, other services on the host). |
Prompt injection. Tool results come from third parties (an issue, a page, an email). runelay limits what a manipulated agent can do: it cannot read credentials, cannot pin memories (pinned memories go into every agent's instructions, so only the panel can pin) and execute code runs in a WebAssembly sandbox with no access to the server. It can still write unpinned memories and call the tools you connected, so review memory health from time to time.
Abuse and visibility.
Every API key has a sliding-window rate limit (
RUNELAY_RATE_LIMIT_PER_MINUTE, default 240). Over the limit the API answers429withretry-after.Every request made with an API key is audited: tool calls (source, tool, result, duration) and REST calls (method, path, status, IP). Open Chaves de API → Atividade to see one key's timeline.
Network. Every outgoing request (MCP, OAuth, OpenAPI) resolves DNS and checks the address right before it goes out, and redirects are followed one hop at a time with the same check, so DNS rebinding and redirects cannot reach private addresses.
Container. The image starts as root only to fix the ownership of /data, then drops to the unprivileged node user. The application code stays read-only for that user. Keep the 127.0.0.1 binding (the default) and put HTTPS in front.
Backup: copy the data/ folder (the SQLite database) and keep RUNELAY_SECRET somewhere safe. Both are needed to restore.
Update: docker compose pull && docker compose up -d (or git pull && docker compose up -d --build from source). Migrations run on startup.
Health: GET /health returns ok. The container has a healthcheck.
bun install
cp .env.example .env # PUBLIC_URL=http://localhost:5173 for dev
bun run seed # demo user, organization, connections and an API key
bun run dev # API on :4312, panel on :5173 (Vite proxies /v1)apps/
api/ Hono + better-auth + SQLite. Feature modules in src/modules/<feature>/{routes,services,repositories,...}
web/ React + Vite + TanStack Router/Query + Tailwind + motion
cli/ the runelay CLI: login, status, push, pull, sync, connect, import, logout
packages/
shared/ zod schemas, types and the { data, error } Result used by every appScript | |
| API and panel with hot reload |
| Builds the panel (served by the API in production) |
| Compiles the CLI for macOS and Linux into |
|
|
| Biome format and lint |
| Demo data for local development |
🗺️ Roadmap
Tools page with per-tool approval policies
Organization members and invites
Activity log per API key
Menu bar app for macOS (reconnect alerts)
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
One MCP endpoint for Claude, GPT & Gemini: 100+ tools + no-code connectors + agent workers.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
One profile — skills, credentials, and memory — synced to every agent tool via one MCP URL.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Related MCP Servers
FlicenseNot gradedqualityBmaintenanceSelf-hosted MCP gateway that connects Claude, ChatGPT, and other AI agents to 20+ enterprise tools (GitLab, Jira, Notion, Google Workspace, Slack, Grafana, …) with OAuth, audit logs, and zero data leaving your infrastructure3-- AlicenseNot gradedqualityDmaintenanceGives AI coding agents (Claude Code, Cursor, etc.) unified, secure access to dev infrastructure (Vercel, GitHub, Supabase, Cloudflare, GCP) via a single MCP token.MIT
- AlicenseAqualityAmaintenanceOne local gateway for all your MCP servers — shared by every AI coding tool (Claude, Cursor, VS Code, Codex). Set up each server once; keys stay in the OS keychain; lazy discovery keeps agent context small. Local-first, open source.49 npm241MIT
- AlicenseNot gradedqualityFmaintenanceSelf-hosted MCP gateway that connects productivity tools like Jira, Confluence, and Obsidian to AI assistants via a single endpoint.2MIT