# TermDX — full reference

> Everything below is public marketing and documentation copy from termdx.studio, reformatted as plain text for retrieval.

TermDX (termdx.studio) is a software studio building AI products, developer tools, and modern software: AI integrations, developer tools and internal platforms, and custom software in TypeScript and Rust. Book a call: https://cal.com/termdx.studio. Support: support@termdx.studio.


## piper
https://termdx.studio/piper

A keyboard-driven API client for your terminal.

A fast, keyboard-driven API client that runs where you already are. Tab between panels, edit headers and bodies in popups, search your history, read syntax-highlighted JSON, and never reach for the mouse. Postman can keep it.

piper is an interactive API client that runs inside your terminal, built on OpenTUI. It's protocol-agnostic by design: it starts with HTTP, and chaining, WebSocket streaming, and saved collections are what it grows into. Everything is a keystroke: no mouse, no window management, no context switch.

### interactive TUI
Tab through panels, edit headers and body in popups, navigate history with search. Ctrl+/ prints the whole keymap when your fingers forget.

### highlighted JSON
Request and response bodies are pretty-printed and colour-coded, so a payload is something you read rather than decode.

### history
URLs autocomplete from your past requests as you type. The endpoint you hit forty times yesterday is two keystrokes away today.

### one-key exports
Copy the current request as cURL, or yank response text straight to the clipboard. Handing a repro to someone costs one keystroke.

### themes
Tokyo Night, Catppuccin, Nord, Gruvbox and more, switched with Ctrl+T. It should match the rest of your terminal, not fight it.

### protocol-agnostic
HTTP today. Next up: request chaining, which pipes one response into the next like Unix pipes, plus WebSocket streaming and collections with variables.

### Install — piper runs on Bun. Install it, then type piper to launch the TUI.

#### bun (global)
`bun install -g @termdx/piper`

#### source (Bun · MIT)
`git clone https://github.com/termdx/piper`
Source: https://github.com/termdx/piper (MIT unless stated otherwise)

### FAQ

Q: Do I need Bun?
A: Yes. piper runs on Bun, so bun install -g @termdx/piper is the install path. Once it's on your PATH, plain piper launches it.

Q: Is there a mouse mode?
A: There's no need for one. Tab and Shift+Tab cycle panels, Ctrl+Enter sends, Ctrl+M picks the method, Ctrl+B and Ctrl+H open the body and header editors. Ctrl+/ shows the rest.

Q: Can I get a request back out as cURL?
A: Ctrl+E exports the current request as a cURL command, and Ctrl+Y yanks selected response text to the clipboard, for the pull request, the bug report, or the colleague who doesn't have piper yet.

Q: Does it do WebSockets, chaining, or collections?
A: Not yet, and it's honest about that: those are the next three things on the roadmap. Chaining pipes one response into the next, WebSockets stream in real time, and collections bring saved requests with variable substitution.

Q: Is it open source?
A: Yes. MIT, on GitHub. Issues and pull requests are read by people who use it daily.

## codrop
https://termdx.studio/codrop

Your working state, on every machine you own.

codrop keeps code, environments, and .env files in step across every machine you work from. Laptop, desktop, the box under the desk: pick one up and it's already where you left off. git pull is now decorative.

codrop is a Rust daemon that watches a folder, content-addresses every change, and syncs it to your other devices over an encrypted peer-to-peer connection. Devices are identified and authenticated by public key, so you never deal with IP addresses, and it works across LAN, NAT, and hostile café Wi-Fi. It isn't a replacement for git. It's the layer underneath, where your half-finished branch and your .env file live.

### live, not committed
Git records commits; codrop mirrors your working folder in real time. An edit on the laptop shows up on the desktop about a second later: new files, changes, deletes.

### encrypted p2p
Devices talk directly, addressed and authenticated by Ed25519 public key. Connectivity escalates direct → hole-punched → relayed, so no server sits in the middle by default.

### conflicts preserved
Vector clocks, not wall-clock time, order changes, so a newer edit is distinguishable from a concurrent one. One version wins the path; the other is kept under .codrop/conflicts/.

### only changed chunks move
Files are split into content-defined chunks stored by hash, so a small edit to a large file transfers a chunk or two, and identical content is deduplicated across files and versions.

### sane ignores
node_modules, .git, target, dist, build, and .next are excluded out of the box; gitignore syntax covers the rest. It's the escape hatch for secrets, too.

### unix, and honest about it
Exec bits and symlinks travel with the file, and deletes propagate as tombstones. The daemon leans on Unix process APIs, so Windows means WSL.

### Install — Unix-only: prebuilt binaries for macOS (Apple Silicon and Intel) and Linux x86-64. Install it on each machine you want in the set, then check it took with codrop --version.

#### curl (macOS · Linux)
`curl --proto '=https' --tlsv1.2 -LsSf https://github.com/termdx/Codrop/releases/latest/download/codrop-installer.sh | sh`

#### brew (macOS · Linux)
`brew install termdx/tap/codrop`

#### cargo (Rust ≥ 1.91)
`cargo install codrop`

#### source (MIT)
`git clone https://github.com/termdx/Codrop.git`
Source: https://github.com/termdx/Codrop (MIT unless stated otherwise)

### FAQ

Q: Isn't this what git is for?
A: Git records commits. codrop mirrors your working folder in real time. Use both: git for history, PRs, and blame; codrop for the uncommitted stuff between commits: the state you'd otherwise shuttle around with git stash, a USB stick, or a desperate Slack file drop.

Q: How do two machines find each other?
A: Not by IP address. Each folder has a stable endpoint id (run codrop id to print it), and pairing is mutual: run codrop pair with the other machine's id on both sides, then codrop run. More than two machines pair with each other to form a mesh.

Q: Does node_modules sync?
A: No. node_modules, .git, target, dist, build, and .next are ignored by default. Anything else you want kept local goes in .codropignore, which takes gitignore syntax.

Q: Who can read my files?
A: Traffic is end-to-end encrypted between devices you've explicitly paired, and a daemon only accepts trusted peers. Blobs are stored unencrypted at rest under .codrop/, though, so don't sync secrets to a device you don't control, and use codrop ignore to keep a file on one machine.

Q: Which platforms are supported?
A: Prebuilt binaries for macOS on Apple Silicon and Intel, and Linux x86-64. Linux arm64 and musl build from source. Windows isn't supported, because the daemon relies on Unix process and file-permission APIs, so it means WSL, give or take.

Q: What's the licence?
A: MIT. Read the source, fork it, run it on hardware we've never heard of.

## Relay
https://termdx.studio/Relay

Automate your daily standups.

Automate your daily standups. Relay turns every commit, PR, and meeting into a client timeline, a knowledge base that answers your clients, and analytics. No status meeting required. Self-hosted.

Automate your daily standups. Relay is the operating system for client work: it sits in the background, watching the tools you already ship with and turning every commit, PR, meeting, and message into a live timeline and a per-project knowledge base, one that answers your clients, feeds your analytics, and powers an AI chat on your own domain. The status update writes itself.

### automated standups
Relay already saw the commits, the PRs, and what merged. It writes the standup from the timeline and posts it where your team reads it. Nobody types a status update, nobody blocks half an hour to say it out loud.

### timeline
Every commit, PR, meeting, todo, and decision captured against a client and project. “Where are we?” stops being a meeting.

### knowledge engine
Everything tracked is embedded into a per-project knowledge base, the source of truth. Relay AI answers with citations, scoped in SQL, never in prompts.

### analytics
The same timeline that writes your standup adds up: throughput, where a project's time actually went, which client is quiet and which is not. Reported, not assembled by hand.

### client portal
relay.yourcompany.com: your clients see live progress, approve work, and ask Relay AI anything about their project. Your branding, your domain.

### approval on writes only
Reading runs unattended; writing does not. Issues land on GitHub and emails get sent only after you approve them. That is the one place Relay deliberately keeps a human, and external writes are durable and retried.

### integrations
GitHub, GitLab, Bitbucket, Slack, Discord, SMTP. Events flow in, notifications flow out, normalized at the edge, never vendor payloads.

### self-hosted runtime
Declarative YAML manifests become docker-compose: modules, integrations, encrypted secrets. Your stack, your data, your client's trust.

### Access
Private beta — join the waitlist on the product page.

Book a demo: https://cal.com/termdx.studio

### FAQ

Q: Does this actually replace our daily standup?
A: That is the point. Relay already sees the commits, the PRs, and what merged, so it writes the standup from the timeline and posts it where your team reads it. Nobody types a status update, and nobody blocks half an hour to say it out loud. You read it when you want it.

Q: Is Relay self-hosted?
A: Yes. Declarative YAML manifests compile to docker-compose (modules, integrations, encrypted secrets), and the whole stack runs on infrastructure you control. Client data never has to leave it.

Q: Which tools does it connect to?
A: GitHub, GitLab, Bitbucket, Slack, Discord, and SMTP. Events are normalized at the edge, so the timeline stores Relay's own shape rather than whatever a vendor's webhook happened to send.

Q: Does the AI act on my tools by itself?
A: It reads on its own and writes only with you. Standups, portal answers, and analytics are generated unattended. None of that touches your tools. Anything that writes back out, like filing an issue or sending an email, waits for your approval and goes through a durable outbox that retries rather than losing the work.

Q: What do clients actually see?
A: A portal on your domain with your branding: live progress, work waiting on their approval, and a chat with Relay AI that answers from their project's knowledge base, with citations, scoped to their project in SQL.

Q: How is Relay licensed?
A: Relay is commercial software, not open source. You buy a licence and run the stack on your own infrastructure: the source stays ours, the deployment and the client data stay yours.

Q: Can I use it yet?
A: It's in private beta. Join the waitlist or book a call, and we'll come back to you with access, licensing, and what it costs.