copyleftdev/hook-bin: Single-binary webhook inbox — capture, inspect, and debug HTTP webhooks with zero dependencies. Embedded SQLite, live dashboard, cross-platform. Just scp and run. · GitHub

 _                 _    _     _
| |__   ___   ___ | | _| |__ (_)_ __
| '_ \ / _ \ / _ \| |/ / '_ \| | '_ \
| | | | (_) | (_) |   <| |_) | | | | |
|_| |_|\___/ \___/|_|\_\_.__/|_|_| |_|

Single-binary webhook inbox. Accept HTTP, store it, show it. No external dependencies.

• One binary, zero dependencies — no Postgres, no Redis, no Docker Compose. scp it to a box, run it, done.
• Embedded SQLite — WAL mode, crash-safe, deterministic resource bounds. Data lives in a single directory.
• Live dashboard — built-in SPA with live polling, syntax-highlighted JSON, request inspector with full headers and body.
• 134 tests — every handler, every edge case, every error path. cargo test is the only gate.
• Tiny footprint — optimized release build with LTO, stripped symbols, and panic = abort.

# 1. Build (or download a release binary)
cargo build --release

# 2. Run
./target/release/hookbin serve --port 8080

# 3. Create a hook and send a webhook
curl -s http://localhost:8080/api/hooks -X POST | jq .
# => { "id": "abc123xyz", "url": "/h/abc123xyz", ... }

curl -X POST http://localhost:8080/h/abc123xyz \
  -H "Content-Type: application/json" \
  -d '{"event": "deploy", "status": "success"}'
# => 200 OK

# 4. Open http://localhost:8080 to see it in the dashboard

The embedded dashboard provides a complete webhook inspection UI — no separate frontend service needed.

• Hook list with request counts and creation timestamps
• Request timeline with method badges and relative timestamps
• Request inspector — headers, body, query params, and metadata
• Syntax-highlighted JSON with collapsible body viewer
• Live polling — new requests appear automatically
• Responsive layout — works on desktop and mobile

All API endpoints return structured JSON with error suggestions:

{
  "error": "not found: hook abc123xyz",
  "suggestion": "Check the hook ID and try again"
}

Three-layer config: defaults -> TOML file -> CLI flags (CLI always wins).

hookbin serve [OPTIONS]

# hookbin.toml
port = 8080
data = "/var/lib/hookbin"
max_hooks = 50
max_payload = 2097152
max_requests = 500
retention = 43200     # 12 hours (in seconds)
rate_limit = 30       # requests per minute per hook

hookbin serve --config hookbin.toml

Hookbin follows the TigerBeetle philosophy: deterministic resource usage, pre-allocated bounds, no surprise OOM.

Note: retention cleanup and rate limiting flags are accepted but not yet enforced — enforcement is coming in M4.

Everything is bounded. Nothing grows without limit.

# Prerequisites: Rust stable toolchain
git clone https://github.com/copyleftdev/hookbin.dev.git
cd hookbin.dev

# Development
cargo build             # Debug build
cargo test              # Run all tests
cargo run -- serve      # Run locally on :3000

# Release
cargo build --release   # Optimized binary
ls -lh target/release/hookbin

src/
  main.rs              # Entry point, CLI parsing
  server.rs            # Axum router + server setup
  db.rs                # SQLite connection, migrations, queries
  models.rs            # Hook, Request structs
  config.rs            # CLI args + TOML config (3-layer merge)
  error.rs             # AppError with structured suggestions
  retention.rs         # Background cleanup task (planned — M4)
  rate_limit.rs        # In-process token bucket (planned — M4)
  handlers/
    ingest.rs          # POST /h/{hook_id} — capture webhook
    hooks.rs           # CRUD hooks
    requests.rs        # List/inspect requests
    dashboard.rs       # Serve embedded UI
    health.rs          # Health check
ui/
  index.html           # Dashboard SPA
  assets/
    app.js             # Vanilla JS — hash routing, live polling
    style.css          # Dashboard styles

MIT