Move proxy from ossrs/proxy repo to proxy directory

Move the SRS proxy server code from the standalone repository
https://github.com/ossrs/proxy into the proxy/ directory of the
main SRS repo. Also update build instructions in origin-cluster.md.

Author: winlinvip

.augment-guidelines

@@ -13,7 +13,7 @@ architecture:
 
   origin_cluster:
     v6_mesh: "DEPRECATED - C++ MESH mode, RTMP only"
-    v7_proxy: "RECOMMENDED - Go-based proxy (https://github.com/ossrs/srsx/tree/main/cmd/proxy-go), all protocols, better scaling"
+    v7_proxy: "RECOMMENDED - Go-based [proxy](./proxy/cmd/proxy-go), all protocols, better scaling"
 
 codebase_structure:
   dirs: "trunk/src/{main,core,kernel,protocol,app}"

proxy/.gitignore

@@ -0,0 +1,10 @@
+.idea
+.claude
+.vscode
+
+srs-proxy
+.go-formarted
+
+# For AI to ignore these files.
+.env
+docs/ignore-worklog.md

proxy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ossrs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

proxy/Makefile

@@ -0,0 +1,23 @@
+.PHONY: all build test fmt clean run
+
+all: build
+
+build: fmt ./srs-proxy
+
+./srs-proxy: cmd/proxy-go/*.go internal/**/*.go
+	go build -o srs-proxy ./cmd/proxy-go
+
+test:
+	go test ./...
+
+fmt: ./.go-formarted
+
+./.go-formarted: cmd/proxy-go/*.go internal/**/*.go
+	touch .go-formarted
+	go fmt ./...
+
+clean:
+	rm -f srs-proxy .go-formarted
+
+run: fmt
+	go run ./cmd/proxy-go

proxy/README.md

@@ -1,6 +1,23 @@
-# Proxy
+# SRSX
 
-Migrated to below repositoties:
+SRSX is the next generation of SRS (Simple Realtime Server), a media server toolkit that includes multiple programs. Currently includes a common proxy server (`cmd/proxy-go`) for any media servers with RTMP/SRT/HLS/HTTP-FLV and WebRTC/WHIP/WHEP protocols support. More programs like `cmd/origin-go` will be added in the future.
 
-* [srsx/cmd/proxy-go](https://github.com/ossrs/srsx/tree/main/cmd/proxy-go) An common proxy server for any media servers with RTMP/SRT/HLS/HTTP-FLV and WebRTC/WHIP/WHEP protocols support.
+## Usage
 
+This project is managed by AI. By default we use Kiro (Amazon Q) CLI, but you can use any other AI tools that read code and docs as context. Setup your AI code tool and ask questions like:
+
+- How to use this project?
+- How to run the proxy server?
+- How to build an Origin Cluster for production?
+
+You can not only use AI to show you the usage of this project, but also use AI to guide you to learn the details of this project, to understand the design and protocols, to learn each documents in docs directory.
+
+## AI Guidelines
+
+- AI assistants should ignore [docs/ignore-worklog.md](docs/ignore-worklog.md) as it's a personal work log that may contain misleading information, hallucinations, or falsehoods. Never rely on this file as a reference.
+- For usage of proxy server and end to end test it, you should load [docs/proxy-usage.md](docs/proxy-usage.md). This is the first step for new users to learn how to use this project. It provides a general and overall view of the proxy server, including practical usage examples and end-to-end testing procedures.
+- For proxy full usage to build an Origin Cluster for SRS media server, please load [docs/proxy-origin-cluster.md](docs/proxy-origin-cluster.md). This is an advanced topic about how to use the proxy server to build the SRS Origin Cluster. Users should read this document to learn more details and architectures about proxy and Origin Cluster.
+- For proxy server: To understand proxy system design, you should load the [docs/proxy-design.md](docs/proxy-design.md). To understand the proxy protocol details, you should load the [docs/proxy-protocol.md](docs/proxy-protocol.md). To understand how load balance works, you should load [docs/proxy-load-balancer.md](docs/proxy-load-balancer.md). To understand the code structure and packages, you should load [docs/proxy-files.md](docs/proxy-files.md).
+
+William Yang<br/>
+June 23, 2025

proxy/cmd/proxy-go/main.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2025 Winlin
+//
+// SPDX-License-Identifier: MIT
+package main
+
+import (
+	"context"
+	"os"
+
+	"proxy/internal/bootstrap"
+)
+
+func main() {
+	bs := bootstrap.NewBootstrap()
+	if err := bs.Start(context.Background()); err != nil {
+		os.Exit(-1)
+	}
+}

proxy/docs/proxy-design.md

@@ -0,0 +1,67 @@
+# Design
+
+## Overview
+
+**proxy-go** is a stateless media streaming proxy with built-in load balancing that enables building scalable origin clusters. The proxy itself acts as the load balancer, routing streams from clients to backend origin servers.
+
+```
+Client → Proxy (with Load Balancer) → Backend Origin Servers
+```
+
+Since the proxy is stateless, you can deploy multiple proxies behind a load balancer (like AWS NLB) for horizontal scaling:
+
+```
+Client → AWS NLB → Proxy Servers → Backend Origin Servers
+```
+
+## Deployment Modes
+
+### Single Proxy Mode
+
+**Use case**: Moderate amount of streams requiring multiple origin servers (each stream has few viewers). The total stream count is manageable by a single proxy server. Uses memory-based load balancing (no Redis needed).
+
+**Architecture**:
+
+```
+                                       +--------------------+
+                               +-------+ Origin Server A    +
+                               +       +--------------------+
+                               +
++-----------------------+      +       +--------------------+
++   Proxy Server        +------+-------+ Origin Server B    +
++ (Memory LB)           +      +       +--------------------+
++-----------------------+      +
+                               +       +--------------------+
+                               +-------+ Origin Server C    +
+                                       +--------------------+
+```
+
+### Multi-Proxy Mode (Scalable)
+
+**Use case**: When a single proxy becomes a bottleneck. Supports a large number of streams across many origin servers, with limited viewers per stream. Redis is required for state synchronization between proxies.
+
+**Architecture**:
+
+```
+                         +-----------------------+
+                     +---+ Proxy Server A        +------+
++-----------------+  |   +-----------+-----------+      +
+|    AWS NLB      +--+               |                  +
++-----------------+  |          (Redis Sync)            + Origin Servers
+                     |   +-----------+-----------+      +
+                     +---+ Proxy Server B        +------+
+                         +-----------------------+
+```
+
+### Complete Cluster (Edge + Proxy + Origins)
+
+**Use case**: Very large deployments with both numerous streams AND numerous viewers. Edge servers aggregate upstream connections - fetching one stream from upstream to serve multiple viewers, dramatically reducing load on proxy and origin servers.
+
+**Architecture**:
+
+```
+Edge Servers → Proxy Servers → Origin Servers
+(Proxy + Cache)   (Proxy)      (SRS/Media)
+```
+
+> **Note**: Future edge servers will be implemented as proxy servers with caching enabled, creating a unified architecture where the same codebase serves both proxy and edge roles. The edge cache aggregates viewer connections, so thousands of viewers can watch the same stream while only requesting it once from upstream.

proxy/docs/proxy-files.md

@@ -0,0 +1,67 @@
+# Codebase Structure
+
+This document provides an overview of the Go codebase organization.
+
+## Directory Structure
+
+```
+/
+├── cmd/proxy-go/
+│   └── main.go                 # Application entry point
+└── internal/
+    ├── debug/                  # Go profiling support
+    ├── env/                    # Configuration management
+    ├── errors/                 # Error handling with stack traces
+    ├── lb/                     # Load balancer (memory/Redis)
+    ├── logger/                 # Logging and request tracing
+    ├── protocol/               # Protocol servers (RTMP, HTTP, WebRTC, SRT, API)
+    ├── rtmp/                   # RTMP protocol implementation
+    ├── signal/                 # Graceful shutdown handling
+    ├── sync/                   # Concurrency utilities
+    ├── utils/                  # Common utilities
+    └── version/                # Version information
+```
+
+## Internal Packages
+
+### debug
+Go profiling support via pprof, controlled by `GO_PPROF` environment variable.
+
+### env
+Configuration management using environment variables. Loads `.env` file and provides defaults for all server settings.
+
+### errors
+Enhanced error handling with stack traces. Provides error wrapping and root cause extraction.
+
+### lb
+Load balancer system supporting both single-proxy (memory-based) and multi-proxy (Redis-based) deployments.
+- `lb.go` - Core interfaces and types
+- `mem.go` - Memory-based load balancer
+- `redis.go` - Redis-based load balancer
+- `debug.go` - Default backend for testing
+
+### logger
+Structured logging with context-based request tracing. Provides log levels: Verbose, Debug, Warning, Error.
+
+### protocol
+Protocol server implementations for all supported streaming protocols:
+- `rtmp.go` - RTMP protocol stack
+- `http.go` - HTTP streaming (HLS, HTTP-FLV, HTTP-TS)
+- `rtc.go` - WebRTC server (WHIP/WHEP)
+- `srt.go` - SRT server
+- `api.go` - HTTP API server
+
+### rtmp
+Low-level RTMP protocol implementation including handshake and AMF0 serialization.
+
+### signal
+Graceful shutdown coordination. Catches SIGINT/SIGTERM and implements timeout-based shutdown.
+
+### sync
+Thread-safe generic Map wrapper around `sync.Map` for connection tracking and caching.
+
+### utils
+Common utility functions for HTTP responses, JSON marshaling, and parsing.
+
+### version
+Version information and server identification.