DevTools

All-in-one Developer Utility Platform

Created by Blitz (@blitzlabx)

---

Overview

DevTools is a production-ready, zero-authentication developer utility platform. It provides a polished web UI and a complete REST API for everyday engineering tasks: JSON processing, DNS lookups, JWT inspection, hashing, regex testing, cron parsing, color contrast, QR codes, and more.

No accounts. No database. Just tools.

Features

• 35+ utilities organized by category
• Modern responsive dashboard with search and local favorites
• Versioned REST API (/api/v1/...) usable independently of the UI
• Security-first: SSRF protection, rate limits, size limits, sanitized Markdown
• Production Docker image and Render-ready configuration
• Health endpoints (/ping, /health) for UptimeRobot and load balancers

Feature Catalog

Category	Tools
JSON	Validator, Beautifier, Minifier, Flatten, Unflatten, Diff, Transform
Network	URL Parser, Redirect Checker, Metadata Extractor, DNS Lookup (A/AAAA/MX/TXT/NS/CNAME/SOA/CAA), Header Analyzer, HTTP Request Tester
Encoding	Hash (MD5/SHA/BLAKE2), HMAC, Base64 encode/decode, URL encode/decode, UUID generate/validate, Secret generator
Security	JWT Decoder (inspect only — no cracking or forging)
Text	Regex Tester, Markdown Renderer (sanitized HTML), Text Diff, Statistics, Transformer
Time	Timestamp converter, Timezone converter, Cron parser/explainer/next-runs
Misc	Color converter, WCAG contrast checker, QR code generator, MIME inspector

Architecture

devtools/
├── app/
│   ├── main.py              # FastAPI application factory
│   ├── api/v1/              # REST route modules
│   ├── core/                # config, security, rate limit, schemas, exceptions
│   ├── tools/               # Independent utility implementations
│   │   ├── json/
│   │   ├── network/
│   │   ├── encoding/
│   │   ├── security/
│   │   ├── text/
│   │   ├── time/
│   │   └── misc/
│   ├── templates/           # Jinja2 UI
│   └── static/              # CSS / JS
├── tests/
├── Dockerfile
├── render.yaml
├── requirements.txt
└── README.md

Each utility lives in its own module under app/tools/ and is exposed through a thin FastAPI router. Shared concerns (validation, SSRF, rate limits, response envelope) live in app/core/.

Quick Start (Local)

git clone https://github.com/blitzlabx/devtools.git
cd devtools
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\\Scripts\\activate
pip install -r requirements.txt
export PYTHONPATH=.
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Open http://localhost:8000

API docs: http://localhost:8000/api/docs

Docker

docker build -t devtools .
docker run --rm -p 8000:8000 -e PORT=8000 devtools

The container respects the PORT environment variable (required by Render).

Render Deployment

1. Push the repository to GitHub.
2. Create a new Web Service on Render and connect the repo.
3. Runtime: Docker.
4. Health check path: /health.
5. Render injects PORT automatically; the Dockerfile CMD already uses it.

Alternatively apply the included render.yaml:

# From the Render dashboard: New → Blueprint → select this repo

API

Base path: /api/v1

Envelope

Success:

{
  "success": true,
  "data": { },
  "error": null,
  "meta": {}
}

Error:

{
  "success": false,
  "error": {
    "code": "validation_error",
    "message": "...",
    "details": {}
  }
}

Health

Method	Path	Description
GET	/ping	Returns {"ping":"pong"}
GET	/health	Status, version, service name

Tool endpoints (selection)

Method	Path	Body example
POST	/api/v1/json/validate	{"text":"{\\"a\\":1}"}
POST	/api/v1/json/beautify	{"text":"...","indent":2}
POST	/api/v1/json/minify	{"text":"..."}
POST	/api/v1/json/flatten	{"text":"...","separator":"."}
POST	/api/v1/json/diff	{"left":"...","right":"..."}
POST	/api/v1/network/dns	{"hostname":"example.com"}
POST	/api/v1/network/url/parse	{"url":"https://..."}
POST	/api/v1/network/headers/analyze	{"url":"https://..."}
POST	/api/v1/network/http	{"url":"...","method":"GET"}
POST	/api/v1/encoding/hash	{"text":"hello","algorithm":"sha256"}
POST	/api/v1/encoding/base64/encode	{"text":"hi"}
POST	/api/v1/encoding/uuid/generate	{"version":4}
POST	/api/v1/security/jwt/decode	{"token":"eyJ..."}
POST	/api/v1/text/regex	{"pattern":"\\\\w+","text":"..."}
POST	/api/v1/text/markdown	{"text":"# Hello"}
POST	/api/v1/time/cron	{"expression":"0 9 * * 1-5"}
POST	/api/v1/misc/color	{"color":"#3d7eff"}
POST	/api/v1/misc/qrcode	{"data":"https://..."}
GET	/api/v1/tools	List all tools and categories

curl examples

# Health
curl -s https://your-app.onrender.com/health

# JSON beautify
curl -s -X POST https://your-app.onrender.com/api/v1/json/beautify \\
  -H 'Content-Type: application/json' \\
  -d '{"text":"{\\"b\\":2,\\"a\\":1}","indent":2}'

# SHA-256 hash
curl -s -X POST https://your-app.onrender.com/api/v1/encoding/hash \\
  -H 'Content-Type: application/json' \\
  -d '{"text":"hello","algorithm":"sha256"}'

# DNS lookup
curl -s -X POST https://your-app.onrender.com/api/v1/network/dns \\
  -H 'Content-Type: application/json' \\
  -d '{"hostname":"example.com","record_types":["A","MX"]}'

# JWT decode
curl -s -X POST https://your-app.onrender.com/api/v1/security/jwt/decode \\
  -H 'Content-Type: application/json' \\
  -d '{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}'

Python example

import httpx

BASE = "https://your-app.onrender.com"

r = httpx.post(f"{BASE}/api/v1/encoding/hash", json={
    "text": "DevTools by Blitz",
    "algorithm": "sha256",
})
print(r.json()["data"]["hex"])

Configuration

Environment variables (optional):

Variable	Default	Description
PORT	8000	Listen port (Render sets this)
DEBUG	false	Enable debug / reload
RATE_LIMIT_ENABLED	true	Toggle rate limiting

Security

• SSRF protection on all outbound HTTP/DNS helpers (blocks private/reserved IPs and credentialed URLs)
• Rate limiting via SlowAPI (stricter limits on network tools)
• Request size limits (JSON/text capped)
• Timeouts on network operations
• Markdown output sanitized with Bleach
• JWT tool never verifies or forges — decode/inspect only
• No arbitrary code execution endpoints

Rate Limits

Scope	Default
General tools	60 / minute
Expensive (diff, transform)	20–30 / minute
Network (DNS, HTTP, redirects)	15 / minute

Testing

export PYTHONPATH=.
pytest tests/ -q

Lint / format:

ruff check app tests
ruff format app tests

Limitations

• Network tools depend on outbound connectivity from the host (Render free tier allows it).
• DNS resolution uses the container's resolver.
• Large payloads are rejected by design to protect the service.
• JWT signature verification is intentionally not offered.

Contributing

Issues and pull requests are welcome under the Blitz / blitzlabx project.

1. Fork the repository
2. Create a feature branch
3. Add tests for new utilities
4. Ensure pytest and ruff pass
5. Open a PR

Credits

DevTools is created and maintained by Blitz (blitzlabx).

All project credit goes to Blitz.

License

MIT License — see LICENSE file for details.