rewynd

A zero-config, OTLP-native flight recorder for your backend. It silently records every HTTP request, database query, outbound call, log line, and exception during local development, correlates them per request, and lets you — or your coding agent — see exactly what happened. No console.log, no re-running.

Laravel Telescope, reborn for Node — terminal-native, and the first backend recorder your coding agent can actually drive. OpenTelemetry under the hood, zero config on top. Runs entirely on your machine.

v0.1.0 is live. The core, the TUI, the CLI, the agent loop, the MCP server, Node + Python capture, and header/body recording all work today — install below. Stars and feedback welcome.

Install

# macOS / Linux — grab the binary:
curl -fsSL https://raw.githubusercontent.com/SrinjoyDev/rewynd/main/scripts/install.sh | sh

# …or via npm (the CLI + the Node capture shim, one package):
npm i -D rewynd

# …or Go:
go install github.com/SrinjoyDev/rewynd/core/cmd/rewynd@latest

# Python capture shim:
pip install rewynd

Windows binaries are on the releases page, or build from source — see CONTRIBUTING.

Related MCP server: MCP Debugger

The problem

Frontend devs have the Chrome DevTools network tab. Backend devs have print. When an endpoint is slow or broken, you sprinkle console.log, re-run the request five times, and squint at which SQL fired. And coding agents have it worse — they write backend code and fly blind, unable to see what it actually did.

rewynd is the network tab for your backend — for humans and agents.

Quick start

# In your Node project (Express, Fastify, …), after installing (see Install above):
# run your normal dev command through rewynd — it auto-starts the recorder:
rewynd run npm run dev

# In another terminal:
rewynd tui                     # the live dashboard — watch requests stream in, click the broken one
rewynd ls                      # or list them; `rewynd show <id>` for one request's full story

$ rewynd show 6928a80f
GET /api/users  ->  200  (15ms)

DETECTIONS
  ! n_plus_one — N+1 query — 10 identical statements

QUERIES (11)
      2ms  SELECT id, name FROM users ORDER BY id
      1ms  SELECT id, title FROM posts WHERE user_id = $1
      …  ×10  (the N+1, obvious at a glance)

LOGS (2)
  [info] listing users
  [info] assembled users with posts

For your coding agent — the differentiator

rewynd gives agents a tight, structured clear → trigger → watch → read → fix loop so they can debug a backend autonomously:

rewynd clear                                   # clean slate
curl localhost:3000/api/orders                 # the agent triggers the endpoint
rewynd watch --status 5xx --timeout 10s --json # blocks until it lands, prints the full trace
rewynd diagnose <id>                           # "what's wrong here" in one line

watch returns the failing SQL with its params, the exception and stack, and any detected N+1 — as JSON the agent reads directly.

Or skip the CLI: rewynd ships an MCP server so agents introspect the backend natively. Drop this into your Claude Code / Cursor MCP config:

{
  "mcpServers": {
    "rewynd": { "command": "rewynd", "args": ["mcp"] }
  }
}

Tools: get_stats, list_requests, get_request, wait_for_request, diagnose, get_last_error, clear. The server also sends the whole debugging protocol as MCP instructions on connect, so the agent knows when and how to use them.

Ready-made integrations for Claude Code (skill + MCP), Cursor (rules + MCP), Windsurf, OpenCode, Codex, Cline, and Devin live in integrations/ — drop the right file into your project and any agent learns the clear → trigger → watch → read → fix loop.

What it captures, correlated per request

Commands

Privacy — it's all local

No cloud, no account, no telemetry on you. The core binds 127.0.0.1 and never makes an outbound connection. A hard prod guard refuses to start under NODE_ENV=production. Secrets are redacted; bodies are size-capped. Your request data never leaves your machine.

How it works

your app ─(stock OpenTelemetry, configured by the shim)→ OTLP ─→ rewynd core ─→ SQLite
                                                                    │
                                              TUI · CLI · MCP read the same recording

The shim stands on OpenTelemetry's auto-instrumentation (you never see OTel config). The Go core is a single static binary: OTLP receiver → correlation → detections → embedded SQLite, with the TUI, CLI, and MCP as thin clients over it.

Supported stacks

Node.js — Express, Fastify, NestJS (anything on Node's http); pg, mysql2, Drizzle, Sequelize, Knex; fetch / axios; console, pino, winston. One command: rewynd run <your dev command>.

Python — FastAPI, Flask, Django; psycopg2, SQLAlchemy; requests, httpx; stdlib logging. One command: pip install rewynd && rewynd-run <your command>.

Both feed the same core over OTLP, so the TUI, CLI, and MCP work identically across languages. Adding a language is a thin shim, never a core rewrite.

Roadmap

• Zero-config capture + per-request correlation (Node, ESM/tsx)

• Go core: OTLP receiver, SQLite store, N+1 detection

• CLI + the agent watch loop, rewynd run launcher

• MCP server (rewynd mcp) + mcp.json quickstart

• The live TUI (request list + waterfall)

• N+1, slow-query, and slow-request detection

• Header capture + redaction; outbound HTTP

• Python shim (FastAPI/Flask/Django) over the same core — the multi-language unlock

• Request/response body capture (redacted, size-capped)

• v0.1.0 released: cross-platform binaries, npm + PyPI packages, install script

• Agent-native: MCP instructions + get_stats; drop-in integrations for Claude Code, Cursor, Windsurf, OpenCode, Codex, Cline, Devin

• TUI filtering + search; more examples (Nest, Next, Prisma)

• gRPC OTLP intake; optional trace export

Contributing

See CONTRIBUTING.md. The repo is a pnpm + Go monorepo: core/ (Go), packages/shim-node/ (the shim), examples/express-postgres/ (demo + fixture).

License

MIT