fbi-proxy 1.0.0

package/.gitattributes

@@ -0,0 +1,31 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.ts text
+*.js text
+*.json text
+*.yml text
+*.yaml text
+*.md text
+*.txt text
+*.sh text eol=lf
+*.bat text eol=crlf
+
+# Declare files that will always have CRLF line endings on checkout.
+*.bat text eol=crlf
+
+# Declare files that will always have LF line endings on checkout.
+*.sh text eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.exe binary
+*.dll binary
+*.so binary
+*.dylib binary

package/.github/workflows/release.yml

@@ -0,0 +1,112 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build proxy binary
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            binary_name: proxy-linux-x64
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+            binary_name: proxy-linux-arm64
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            binary_name: proxy-windows-x64.exe
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+            binary_name: proxy-windows-arm64.exe
+          - os: macos-latest
+            target: x86_64-apple-darwin
+            binary_name: proxy-macos-x64
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            binary_name: proxy-macos-arm64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install cross-compilation tools
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+
+      - name: Build binary
+        working-directory: rs
+        run: |
+          cargo build --release --target ${{ matrix.target }}
+
+      - name: Prepare binary
+        shell: bash
+        run: |
+          mkdir -p release
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            cp rs/target/${{ matrix.target }}/release/proxy.exe release/${{ matrix.binary_name }}
+          else
+            cp rs/target/${{ matrix.target }}/release/proxy release/${{ matrix.binary_name }}
+            chmod +x release/${{ matrix.binary_name }}
+          fi
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.binary_name }}
+          path: release/${{ matrix.binary_name }}
+
+  release:
+    name: Semantic Release
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    permissions:
+      contents: write
+      id-token: write
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: release
+
+      - name: Flatten artifacts
+        run: |
+          mkdir -p release-flat
+          find release -type f -exec cp {} release-flat/ \;
+          ls -la release-flat/
+
+      - name: Run semantic-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: bunx semantic-release

package/.releaserc.json

@@ -0,0 +1,37 @@
+{
+  "branches": ["main"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    [
+      "@semantic-release/changelog",
+      {
+        "changelogFile": "CHANGELOG.md"
+      }
+    ],
+    [
+      "@semantic-release/npm",
+      {
+        "npmPublish": true
+      }
+    ],
+    [
+      "@semantic-release/github",
+      {
+        "assets": [
+          {
+            "path": "release/**",
+            "label": "Binary releases"
+          }
+        ]
+      }
+    ],
+    [
+      "@semantic-release/git",
+      {
+        "assets": ["package.json", "CHANGELOG.md"],
+        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+      }
+    ]
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# 1.0.0 (2025-07-25)
+
+
+### Bug Fixes
+
+* **main:** dont ignore caddy ([74e1e8c](https://github.com/snomiao/fbi-proxy/commit/74e1e8c070e08ae31bac498f583f1807b8a20920))
+* **main:** init bun ([9b7baed](https://github.com/snomiao/fbi-proxy/commit/9b7baedf1f80a55cc818f97099cc5c854fda0d9e))
+* **main:** setup ([0a00110](https://github.com/snomiao/fbi-proxy/commit/0a00110e6ace713265b4dbf3980515e77663e8a0))
+
+
+### Features
+
+* add Caddyfile and CLI for proxy server setup with WebSocket support ([8ed37b0](https://github.com/snomiao/fbi-proxy/commit/8ed37b0652a33beae86b2b6c3881534c1bb9b1bc))
+* migrate to semantic-release for automated releases ([b3a5f8a](https://github.com/snomiao/fbi-proxy/commit/b3a5f8a1e2cfc92d7e93a941d15acb43ce896d3f))
+* proxy.rs now reads PROXY_PORT environment variable ([1616790](https://github.com/snomiao/fbi-proxy/commit/1616790c855d49f4f5c78b31022dca6caa6148f3))
+* update Caddyfile to use FBIPROXY_PORT and enhance cli.ts with help options and improved proxy handling ([0de99ff](https://github.com/snomiao/fbi-proxy/commit/0de99ff4e1c0cd15be579ac98f4b19479c320210))
+* update project configuration and dependencies ([ab9d8cf](https://github.com/snomiao/fbi-proxy/commit/ab9d8cfe7cfb200c57df915e7ab4ede3a7b0a703))

package/Caddyfile

@@ -0,0 +1,19 @@
+{
+	admin off
+	# TODO: add ondemand tls endpoint to cli.ts
+	# - [Global options (Caddyfile) — Caddy Documentation]( https://caddyserver.com/docs/caddyfile/options#on-demand-tls )
+	# make a endpoint to handle /CHECK_TLS?domain=..., and return 200 if domain is valid
+	# 
+	# on_demand_tls {
+	# 	ask http://localhost:{$PROX}/CHECK_TLS
+	# }
+}
+
+# unwrap all https
+*, *.*, *.*.*, *.*.*.* {
+	tls internal {
+		on_demand
+	}
+
+	reverse_proxy :{$FBIPROXY_PORT:24306}
+}

package/Dockerfile

@@ -0,0 +1,38 @@
+# Multi-stage Docker build for FBI Proxy
+FROM rust:1.70-alpine AS builder
+
+WORKDIR /app
+COPY rs/ ./rs/
+WORKDIR /app/rs
+
+# Install build dependencies
+RUN apk add --no-cache musl-dev
+
+# Build the proxy
+RUN cargo build --release --target x86_64-unknown-linux-musl
+
+# Runtime stage
+FROM node:18-alpine
+
+# Install Caddy and Bun
+RUN apk add --no-cache caddy curl bash
+RUN curl -fsSL https://bun.sh/install | bash
+ENV PATH="/root/.bun/bin:$PATH"
+
+WORKDIR /app
+
+# Copy the built proxy binary
+COPY --from=builder /app/rs/target/x86_64-unknown-linux-musl/release/proxy /app/bin/proxy
+RUN chmod +x /app/bin/proxy
+
+# Copy application files
+COPY package.json ./
+COPY src/ ./src/
+COPY Caddyfile ./
+
+# Install dependencies
+RUN npm install
+
+EXPOSE 24306 80 443
+
+CMD ["bun", "src/cli.ts"]

package/INSTALL.md

@@ -0,0 +1,161 @@
+# FBI Proxy - Installation Guide
+
+FBI Proxy now supports multiple installation methods, **no Rust installation required**!
+
+## 🚀 Quick Install (Recommended)
+
+```bash
+npm install
+npm start
+```
+
+The proxy binary will be automatically downloaded during installation.
+
+## 📦 Installation Methods
+
+### Method 1: Auto-Download (Default)
+
+- **No Rust required** ✅
+- Pre-built binaries downloaded automatically
+- Supports Windows, macOS, and Linux (x64 + ARM64)
+
+```bash
+npm install          # Downloads proxy binary automatically
+npm start           # Starts the proxy system
+```
+
+### Method 2: Build from Source (Optional)
+
+If you have Rust installed and want to build from source:
+
+```bash
+npm run build-proxy    # Builds from Rust source
+npm start              # Starts the proxy system
+```
+
+### Method 3: Docker (Containerized)
+
+For containerized deployment:
+
+```bash
+docker build -t fbi-proxy .
+docker run -p 24306:24306 -p 80:80 -p 443:443 fbi-proxy
+```
+
+## 📋 Available Scripts
+
+| Script                | Description                      | Requires Rust |
+| --------------------- | -------------------------------- | ------------- |
+| `npm install`         | Auto-setup (download or build)   | ❌ No         |
+| `npm start`           | Start the proxy system           | ❌ No         |
+| `npm run dev`         | Development mode with hot reload | ❌ No         |
+| `npm run build-proxy` | Build/download proxy binary      | ❌ No         |
+| `npm run clean-proxy` | Clean built files                | ❌ No         |
+
+## 🔧 Advanced Scripts (Rust Required)
+
+| Script                           | Description       |
+| -------------------------------- | ----------------- |
+| `cd rs && cargo build --release` | Manual Rust build |
+| `cd rs && cargo test`            | Run Rust tests    |
+| `cd rs && cargo fmt`             | Format Rust code  |
+
+## 🏗️ Build Strategy
+
+The build system automatically:
+
+1. **First**: Tries to download pre-built binary from GitHub releases
+2. **Fallback**: If Rust is installed, builds from source
+3. **Manual**: Provides instructions if both fail
+
+## 🌐 Platform Support
+
+| Platform | Architecture | Binary Name             | Status |
+| -------- | ------------ | ----------------------- | ------ |
+| Windows  | x64          | `proxy-windows-x64.exe` | ✅     |
+| macOS    | x64          | `proxy-macos-x64`       | ✅     |
+| macOS    | ARM64        | `proxy-macos-arm64`     | ✅     |
+| Linux    | x64          | `proxy-linux-x64`       | ✅     |
+| Linux    | ARM64        | `proxy-linux-arm64`     | ✅     |
+
+## 🐳 Docker Usage
+
+```bash
+# Build Docker image
+docker build -t fbi-proxy .
+
+# Run container
+docker run -d \
+  --name fbi-proxy \
+  -p 24306:24306 \
+  -p 80:80 \
+  -p 443:443 \
+  -v $(pwd)/Caddyfile:/app/Caddyfile \
+  fbi-proxy
+
+# View logs
+docker logs -f fbi-proxy
+```
+
+## 🔍 Troubleshooting
+
+### Binary Not Found
+
+```bash
+npm run build-proxy  # Try rebuilding/downloading
+```
+
+### All Build Methods Failed
+
+1. Install Rust: https://rustup.rs/
+2. Build manually:
+   ```bash
+   cd rs
+   cargo build --release
+   cp target/release/proxy* ../bin/
+   ```
+
+### Docker Issues
+
+```bash
+# Clean build
+docker build --no-cache -t fbi-proxy .
+
+# Check container logs
+docker logs fbi-proxy
+```
+
+## 🎯 Benefits
+
+- ✅ **No Rust Installation Required** for end users
+- ✅ **Cross-Platform Support** (Windows, macOS, Linux)
+- ✅ **Multiple Architectures** (x64, ARM64)
+- ✅ **Automatic Updates** via GitHub releases
+- ✅ **Fallback to Source Build** when needed
+- ✅ **Docker Support** for containerized deployment
+
+## 🚦 Quick Start Examples
+
+### Development
+
+```bash
+git clone <repo>
+cd fbi-proxy
+npm install     # Auto-downloads proxy binary
+npm run dev     # Start with hot reload
+```
+
+### Production
+
+```bash
+npm install
+npm start
+```
+
+### Docker Production
+
+```bash
+docker-compose up -d
+```
+
+The proxy will automatically handle port encoding (`domain--3000` → `domain:3000`) and forward requests to your local services!

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 snomiao
+
+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.

package/PINGORA_PROXY.md

@@ -0,0 +1,127 @@
+# Pingora-Based Rust Proxy
+
+The proxy functionality has been migrated from TypeScript/Bun to Rust using Cloudflare's **Pingora** framework for maximum performance and reliability.
+
+## Architecture
+
+- **TypeScript (`src/cli.ts`)**: Main entry point that:
+  - Checks for Rust and Caddy installation
+  - Launches the Rust proxy server
+  - Starts Caddy with the appropriate configuration
+- **Rust (`rs/proxy.rs`)**: Ultra high-performance proxy server using Pingora that:
+  - Handles HTTP requests with zero-copy forwarding
+  - Processes host header port encoding (e.g., `example.com--3000` → `example.com:3000`)
+  - Forwards requests to local services with optimal performance
+  - Built-in WebSocket support (handled by Pingora)
+  - Runs on port 24306
+
+## Why Pingora?
+
+**Pingora** is Cloudflare's production-grade HTTP proxy framework built in Rust:
+
+- ⚡ **Performance**: Used by Cloudflare to handle millions of requests per second
+- 🔒 **Security**: Memory-safe Rust with battle-tested proxy logic
+- 🌐 **WebSocket Support**: Built-in WebSocket proxying capabilities
+- 📊 **Observability**: Advanced logging and metrics
+- 🔧 **Flexibility**: Modular design for custom proxy logic
+- 🚀 **Production Ready**: Powers Cloudflare's edge network
+
+## Building
+
+### Using npm/bun scripts:
+
+```bash
+# Build release version
+bun run build-proxy
+
+# Build development version
+bun run build-proxy-dev
+```
+
+### Manual build:
+
+```bash
+cd rs
+cargo build --release
+```
+
+### Platform-specific build scripts:
+
+```bash
+# Linux/macOS
+./build-proxy.sh
+
+# Windows
+build-proxy.bat
+```
+
+## Dependencies
+
+### System Requirements:
+
+- Rust (install from https://rustup.rs/)
+- Caddy web server
+- Bun runtime
+
+### Rust Dependencies:
+
+- `pingora` - Cloudflare's high-performance HTTP proxy framework
+- `async-trait` - Async trait support
+- `regex` - Pattern matching for host processing
+- `env_logger` - Logging infrastructure
+- `tokio` - Async runtime (used by Pingora)
+
+## Features
+
+- **🚀 Ultra High Performance**: Pingora framework used in Cloudflare production
+- **⚡ Zero-Copy Proxying**: Efficient request/response forwarding
+- **🌐 WebSocket Support**: Built-in WebSocket proxying (no custom implementation needed)
+- **🔧 Port Encoding**: Supports special host header format for port specification
+- **📊 Advanced Logging**: Detailed request/response logging and metrics
+- **🛡️ Error Handling**: Production-grade error handling and recovery
+- **🔄 Hot Reloading**: Development-friendly with auto-restart capabilities
+
+## Usage
+
+```bash
+# Start the full proxy system
+bun start
+
+# Development mode with hot reloading
+bun run dev
+```
+
+The proxy will:
+
+1. Start the Pingora-based Rust proxy server on port 24306
+2. Launch Caddy with the configured Caddyfile
+3. Handle all incoming requests with maximum performance
+4. Automatically handle WebSocket upgrades and forwarding
+
+## Proxy Implementation Details
+
+The Pingora implementation uses the `ProxyHttp` trait to:
+
+1. **Request Filter**: Processes incoming requests, extracts host headers, handles port encoding
+2. **Upstream Peer**: Determines the target upstream server dynamically
+3. **Response Filter**: Modifies response headers (removes content-encoding)
+4. **Logging**: Comprehensive request/response logging with error tracking
+
+### Port Encoding Logic
+
+```rust
+// Converts: example.com--3000.domain.com -> example.com:3000
+let target_host = port_regex.replace(host_header, ":$1").to_string();
+```
+
+This allows encoding port numbers in domain names for proxy routing.
+
+## Performance Benefits
+
+Compared to the previous Hyper-based implementation:
+
+- **🏃‍♂️ Faster**: Pingora's optimized request processing
+- **💾 Lower Memory**: Better memory management and pooling
+- **🔄 Better WebSocket**: Native WebSocket support without custom forwarding
+- **📈 Scalability**: Handles more concurrent connections
+- **🔧 Maintainability**: Cleaner code with built-in proxy patterns