Getman

The problem

An API change usually reaches the frontend outside the code.

It arrives in a chat message, a doc, or a shared request collection. The person who tests a request and the person who depends on it rarely see the same evidence, and the contract is often out of date by the time someone reads it.

I wanted the tool that tests requests to keep its data on the developer's machine, and the change itself to travel with the code.

Product vision

Local-first, with Git as the only shared channel.

• Requests, responses, history and secrets stay on the developer's machine.
• A change to an API is a file in the repository, with its contract diff, examples and test evidence.
• Coding agents get the same contract and examples a human reviewer gets, inside limits the developer sets.
• No account, no sync service and no telemetry. Free to use.

Architecture

A Rust core for transport and storage, and one TypeScript core for product logic.

• Tauri 2 shell with a React 19 and TypeScript interface, and Zustand for state.
• Rust handles HTTP, WebSocket, Server-Sent Events, SQLite storage, secrets and file sync. Variables, auth, scripts, the request pipeline, the runner and the importers are pure TypeScript, unit-tested without a webview.
• Secrets are encrypted with AES-256-GCM in the local database. The master key lives in the OS keychain.
• Scripts run in a QuickJS sandbox compiled to WebAssembly, with a 32 MB memory limit and a 5 s default timeout.
• The getman CLI and the local MCP server run requests through the same engine the app uses.
• Projects sync to Git as plain YAML: one file per request, environments with secret values left blank, and change packages under changes/.

Git & MCP workflow

One API change, from backend to frontend, with no server in between.

• A change package records the endpoint, the contract diff, examples, a migration note, commits and evidence.
• The contract diff rates each change as breaking, potentially breaking, non-breaking or unknown, separately for requests and responses.
• Evidence comes only from real runs. Verify now executes the affected requests, and seven labels run from Not tested to Integration verified.
• Change packages move through draft, published and withdrawn.
• Fetch shows incoming packages in the Integration Inbox before anyone pulls.
• Git stays explicit. Fetch, Pull (fast-forward only), Commit and Push use the developer's own Git and credentials.
• The local MCP server exposes 11 read tools and 4 write tools, limited to chosen folders.
• A coding agent's POST, PUT, PATCH or DELETE to a production environment needs approval for each request. --read-only removes every write tool.

Technical challenges

• Blank values never become literal text. A header, query, cookie or auth value that uses an undefined or empty variable is left out and logged, instead of sending {{name}} to the server.
• An error status is not a pass. The CLI used to report a 500 as passed when a request had no tests. Now a 4xx or 5xx fails unless an enabled status assertion pins that status.
• Secrets never reach Git. Secret values are blank in the YAML files, and each developer fills them in once into their own keychain. Agents read them from GETMAN_VAR_<KEY> in the shell that starts them.
• Team sync is merge-safe. Pull is fast-forward only and never merges, stashes or resets. Conflict markers are refused on load and on commit.
• Scripts cannot reach the network. gm.sendRequest throws, so requests are chained through variables instead.
• Agent writes to production are approved one by one. The approval form is part of the MCP client, not a server-wide switch, and I verified it in an interactive Claude Code session.

Testing & results

Numbers from the final run on 2026-10-10, for version 0.1.2.

• 812 of 812 unit and CLI/MCP integration tests pass, across 57 files.
• 72 of 72 Rust tests pass.
• 64 Playwright end-to-end tests pass with 0 failures, and 3 opt-in checks are skipped.
• Every OpenAPI export of the 14 seed projects passes the official OpenAPI 3.1 JSON Schema, and every $ref resolves.
• Two intermittent E2E failures were traced to test races, not app bugs. Each fix comes with a regression test. One importer timeout is still unexplained.
• A macOS universal release build was verified locally: a 14.4 MiB app and an 8.3 MiB disk image.
• Not yet tested: Windows. CI builds the Windows installers, but nothing has been installed or run on a Windows machine. The macOS build is not yet signed.

Demo & downloads

The tutorial is a narrated walkthrough of about 11 minutes, with captions.

It covers installing Getman, everyday API work, the Git files, connecting Claude Code, and one API change from backend to frontend.