# Relay

A keyboard-first API client where everything you build is a plain file on disk.

Relay keeps requests, routines, and environments as readable YAML in a folder you own.
No account, no cloud, no database to export from. Open the workspace in your editor,
review it in a pull request, sync it however you sync files, or hand it to an agent.

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="apps/desktop/promo/relay-request-editor.png">
  <img src="apps/desktop/promo/relay-request-editor-light.png" alt="The Relay request editor: a GET request with query params above a JSON response">
</picture>

## What's inside

**Requests.** Params, headers, body, and auth (basic, bearer, API key, OAuth 2.0) in one
editor, with a cookie jar and an auto-saved history of every send. Paste a curl command
to create a request; copy any request back out as curl. GraphQL bodies get a
schema-aware editor fed by live introspection.

**Routines.** Chain requests into a flow on an auto-layout canvas. Extract values from
responses, branch on conditions, assert on results, wait, or pause for a human pick or
entry. Run the whole flow, run to a step, or re-run a single step against cached data,
and refactor with find and replace across the routine.

**The `{{reference}}` grammar.** One syntax reuses any value: vault keys, step outputs,
extracted variables, and routine inputs, all resolved at send time. Cmd-click a
reference anywhere to peek at what it resolves to.

**Environments and secrets.** A vault holds one column of values per environment. Mark
a value as secret and it moves to the OS keychain; secrets resolve inside the Rust core
at send time and never reach the interface, reports, or exports.

**Webhook listener.** Point any service at a generated URL and inspect what arrives,
headers and body, without opening a port. Save a capture as a request to replay it.

**MCP, both ways.** Connect Relay to MCP servers, or serve your workspace over MCP so
agents can browse, send, and create requests with your vaults in place. Every workspace
also carries generated `llms.txt` and `CLAUDE.md` guides, so agents understand the file
formats without being told.

**Import and export.** Import Postman collections, OpenAPI 3 documents, Bruno
collections, and curl. Export Postman collections, a vault as `.env`, or any request or
routine as a typed TypeScript or JavaScript client.

**Undo for everything.** File mutations are journaled with byte-exact snapshots, undo
works app-wide, and deletes go through the OS trash.

**Network control.** Per-workspace proxy, mTLS client certificates, extra CA
certificates, and custom DNS, kept machine-local and out of the shareable files.

And throughout: a command palette that teaches every shortcut, in-app guides on each
feature's first open, an interface in English, French, or German, and on-device AI naming on
Apple Silicon that never sends a byte anywhere.

## The workspace is files

```yaml
# ~/Relay/requests/Create issue.relay.yaml
schemaVersion: 1
id: 8f3c2b10-6a44-4e2f-9c1a-2d7e5b0f1a23
name: Create issue
request:
  method: POST
  url: https://api.github.com/repos/{{owner}}/{{repo}}/issues
  headers:
    - name: Authorization
      value: Bearer {{githubToken}}
      enabled: true
  body:
    type: json
    value:
      text: |-
        { "title": "Found a bug" }
```

File names follow the names you see in the app. Relay watches for edits made outside
the app and reloads them, so the files stay the source of truth: version them, diff
them, or generate them.

## Install

Download the latest build from the [releases page](https://github.com/Sharko99/relay/releases).
On first launch Relay creates a workspace at `~/Relay` with a few starter files. macOS
may ask you to confirm the first open, since the app comes from outside the App Store.

## Documentation

The full manual lives in [`apps/docs`](apps/docs) and is published as the documentation
site: getting started, core concepts, and a page per feature, plus reference material
for the `{{reference}}` grammar, the on-disk file formats, keyboard shortcuts, and the
MCP tools.

## Development

```
apps/desktop    the app: React frontend (src/) and Rust core (src-tauri/)
apps/docs       the documentation site (Astro + MDX)
docs/           architecture and design notes
```

Prerequisites: Node 20+, pnpm, Rust stable, and the
[Tauri prerequisites](https://tauri.app/start/prerequisites/) for your platform.

```sh
pnpm install
cd apps/desktop && pnpm tauri dev    # builds the Rust core and opens the app
```

Before sending a change:

```sh
pnpm typecheck && pnpm lint && pnpm test     # tsc + astro check, biome, vitest
cd apps/desktop/src-tauri
cargo clippy --all-targets -- -D warnings
cargo test                                   # also regenerates the IPC bindings
```

Start with [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for how the pieces fit and
[docs/CONTRIBUTING.md](docs/CONTRIBUTING.md) for the workflow. The project's
cross-cutting conventions live in [CLAUDE.md](CLAUDE.md); they apply to human and AI
contributors alike.

## Stack

| Layer | Tech |
|---|---|
| Runtime | Tauri 2, a Rust core behind the OS webview |
| Frontend | React 19, TypeScript, Tailwind CSS 4, Vite |
| HTTP engine | Rust `reqwest` with full wire timings |
| Storage | Plain YAML files, SQLite for response history |
| IPC | Generated end-to-end types via `tauri-specta` |

## License

[MIT](LICENSE)