v1.0 is Live

The Open-Source Local Sharing Proxy.

Grip is built for developers who need to quickly share local apps. Run a single command, get a public URL, and keep the option to self-host edge + control-plane when your team needs deeper control.

View Source Code
operator@rpc-edge:~
❯ export GRIP_SEED_TOKEN="sk_test_123"
❯ grip login --token $GRIP_SEED_TOKEN

✓ Token validated and persisted to ~/.grip/token

❯ grip http 8080
Grip Tunnel ActiveCtrl+C to quit
Session: onlineForwarding: https://t-8f2a.rpc.ag/ -> localhost:8080Connections: 0 active

End-to-End Determinism

Grip keeps local sharing simple for developers while separating CLI and edge for predictable behavior and transparent routing.

01

Start grip-edge

Deploy the edge control-plane via Docker, systemd, or native binary. This handles routing and tunnel lifecycles.

02

Seed Authentication

Configure your initial root token via the GRIP_SEED_TOKEN environment variable on the edge.

03

Login via CLI

Run grip login to validate your token against GET /v1/tokens/validate and persist it locally.

04

Initiate Tunnel

Run grip http <PORT>. The CLI creates the tunnel via POST /v1/tunnels.

05

Edge Routing

The edge issues a public URL pattern (<id>.<base><path>) and immediately forwards inbound traffic to your local port.

bash (Server)
# 1. Start edge
$ docker run -p 80:80 -p 443:443 \
    -e GRIP_SEED_TOKEN="sk_live_xyz" \
    rpc-ag/grip-edge:latest
bash (Local Operator)
# 2. Authenticate
$ grip login --token sk_live_xyz
✓ Login successful

# 3. Expose local port 3000
$ grip http 3000
Tunnel created: https://app-123.rpc.ag/

Built for Fast Local Proxying

Optimized for quick local sharing during development, with reliability and observability primitives for teams that self-host.

CLI

Developer-First CLI

Share localhost in seconds with login, http, tcp, status, and logout commands. Actionable diagnostics help developers move fast.

API

Deterministic Control API

Stable JSON error envelopes (CONTROL_* codes). Strict idempotency enforcement on mutating endpoints ensures no zombie tunnels.

OPS

Reliability Guardrails

Actor model architecture with mailbox capacity profiles, fairness limiters, saturation guardrails, and jittered reconnect backoffs.

OBS

Debug-Friendly Observability

Export Prometheus metrics, trace latency decomposition, and monitor live tunnel status with the built-in ratatui dashboard.

SEC

Security Foundation

Heavily tested domain modules for RBAC templates, scoped token governance, workspace hierarchy, and endpoint collision policies.

DEP

Deployment Flexibility

Run easily in Docker for dev loops, or map to systemd and Caddy for production-grade reverse proxying and TLS termination.

!

Production Constraints (v1.0)

We believe in transparent engineering. While Grip is built on robust, battle-tested domain modules, the current production wiring has specific behavioral constraints you should plan for:

  • ✓Control-plane tunnel state is currently in-memory. Restarting grip-edge clears active tunnels.
  • ✓The shared wildcard endpoint flow is the primary routing path today.
  • ✓While TCP tunnel lifecycles exist in the API, the current edge forwarding implementation is optimized purely for HTTP proxying.