update docs

Author: trevatk

README.md

@@ -8,7 +8,9 @@ Routing & Tunnel Management
 
 ## 📖 Table of Contents
 
-[🚀 Quick Start](#-quick-start)
+[🚀 Quick Start](#-quick-start)\
+[🏗️ Architecture](docs/architecture.md)\
+[⚙️ Config](docs/config.md)
 
 ## 🚀 Quick Start
 

docs/architecture.md

@@ -0,0 +1,39 @@
+🏗️ Architecture
+
+This document provides a high-level overview of the components that make up Dino and how they interact to provide dynamic routing and tunneling.
+
+📐 System Diagram
+
+![Diagram](assets/architecture.png)
+
+⌨️ CLI (Command Line Interface)
+
+The Dino CLI is a statically linked Go binary that acts as the primary administrative tool. It communicates with the Server via gRPC to:
+
+Provision and de-provision tunnels.\
+Configure hostname-to-service routing rules.\
+Monitor real-time tunnel health and throughput metrics.
+
+🔌 API (Server)
+
+The core of Dino is a high-performance H2C (HTTP/2 Cleartext) server. It serves as the single point of truth for the system state.
+
+Dependency Injection: Built using uber-go/fx for a modular, testable lifecycle.\
+Persistence: Manages the state of routes and tunnels (via the Service layer you saw in the code).\
+Protocols: Uses gRPC for type-safe, low-latency communication between the CLI and the backend.
+
+󰔚 Tunnel Management
+
+Tunnel Management handles the "Physical" layer of the connection. It abstracts the complexity of different network interfaces into a unified logical tunnel_id.
+
+Isolation: Ensures that traffic arriving on one tunnel cannot "hop" to another unless explicitly routed.\
+Lifecycle: Manages the handshake, keep-alives, and clean teardown of network pipes.\
+Abstraction: Provides a common interface for Dino to interact with local TUN/TAP devices or remote overlay peers.
+
+󰄱 Proxy (Data Plane)
+
+The Proxy is the engine that moves bits. It is responsible for the actual "forwarding" decision based on the configuration received from the API.
+
+Host-Based Routing: Inspects the SNI or Host header of incoming requests to match them against the active routing table.\
+Protocol Translation: Supports mapping incoming traffic to various destination protocols (as defined in dest_protocol).\
+Flow Control: Handles the stream multiplexing between a single tunnel entry-point and multiple internal microservices.

docs/assets/architecture.png

@@ -0,0 +1,27 @@
+# ⚙️ Config
+
+servers and tunnels can be configured using environment variables. this page will serve a dictionary for all variables and their purpose. 
+
+## Server
+
+`LOG_LEVEL`         `DEBUG`             global log level
+
+`SERVER_HOST`       `127.0.0.1`         server api bind host\
+`SERVER_PORT`       `50051`             server api bind port
+
+`DB_USERNAME`       `dino`              database user\
+`DB_PASSWORD`       `dino`              database user password\
+`DB_HOST`           `postgres`          database host\
+`DB_PORT`           `5432`              database port\
+`DB_NAME`           `dino`              database name\
+`DB_EXRA_PARAMS`    `sslmode=disable`   pgxpool dial string params
+
+`AUTH_JWT_DURATION` `-1`                jwt duration\
+`AUTH_JWT_ISSUER`   `dino.local`        jwt issuer\
+`AUTH_JWT_AUD`      `dino`              jwt audience (`,` split list)
+
+## Tunnel
+
+`TUNNEL_ID`                                     tunnel id\
+`TUNNEL_TOKEN`                                  tunnel token\
+`TUNNEL_ENDPOINT`   `tunnel.dino.local:4222`    tunnel endpoint

docs/config.md

@@ -1 +1,19 @@
 # Route
+
+This document serves as a breakdown of Dino Route.
+
+## Core Concepts
+
+Dino Routes are used when routing tunnel traffic after exiting the tunnel. The routing table will match based on Route `hostname` and dial the destination provided at Route creation. 
+
+example Route creation using Dino CLI.
+
+```bash
+dino route add \
+    -a localhost:8888 \ # local address
+    -p whoami.dino.local \ # hostname
+    -r http \ # protocol
+    -x hello \ # route name
+    -t api.dino.local:50051 # api server endpoint
+```
+

docs/route.md

@@ -1 +1,17 @@
-# Tunnel
+# 🛤️ Tunnel
+
+This document explains how Dino maps incoming tunnel traffic to internal destinations. 
+
+## Core Concept
+
+Dino operates a control plane for network tunnels. Functionality is different from wireguard as it does not interact with physical devices. Instead it manages the routing table that dictates where traffic goes once it exits the tunnel.
+
+example tunnel creation using Dino CLi.
+```bash
+    dino tunnel add hello -t api.dino.local:50051
+```
+
+## Authentication
+
+
+

docs/tunnel.md

@@ -59,6 +59,7 @@ type Server struct {
 	KeyPath  string `env:"SSL_KEY_PATH"`
 }
 
+// JWT
 type JWT struct {
 	Duration int64    `env:"DURATION, default=-1"` // jwt token duration in seconds
 	Issuer   string   `env:"ISSUER, default=dino.local"`
@@ -74,7 +75,7 @@ type Authenticator struct {
 type Tunnel struct {
 	ID       string `env:"ID"`
 	Token    string `env:"TOKEN"`
-	Endpoint string `env:"ENDPOINT"`
+	Endpoint string `env:"ENDPOINT, default=tunnel.dino.local:4242"`
 }
 
 // Configs