fbi-proxy 1.2.0 → 1.4.0

package/Caddyfile

@@ -7,13 +7,41 @@
 	# on_demand_tls {
 	# 	ask http://localhost:{$PROX}/CHECK_TLS
 	# }
+	servers {
+		trusted_proxies static private_ranges
+		trusted_proxies_strict
+	}
+	# auto_https disable_redirects
 }
 
 # unwrap all https
-*, *.*, *.*.*, *.*.*.* {
+http://*, http://*.*, http://*.*.*, http://*.*.*.*, https://*, https://*.*, https://*.*.*, https://*.*.*.* {
 	tls internal {
 		on_demand
 	}
+	# match **.fbi.com use regex match against to host
+	@subhost {
+		header_regexp subhost Host ^((?:(.+)\.)?{$FBIHOST:fbi.com})$
+	}
+	@fullhost {
+		header_regexp fullhost Host ^(.+)$
+	}
+	# debug
+	# handle @subhost {
+	# 	respond "https://{re.subhost.1}{uri} => http://{re.subhost.2}{uri}"
+	# }
+
+	reverse_proxy @subhost :{$FBIPROXY_PORT:24306} {
+		# strip the fbi.com part from the host
+		header_up Host {re.subhost.2}
+		# header_up X-Forwarded-Host {re.subhost.1}
+	}
+	reverse_proxy @fullhost :{$FBIPROXY_PORT:24306} {
+		header_up Host {re.fullhost.1}
+	}
+
+	# 3000.amd.fbi.com => *.amd.fbi.com goes to amd.fbi.com with 3000.localhost host
 
-	reverse_proxy :{$FBIPROXY_PORT:24306}
+	# for all other hosts, 404
+	# respond 404
 }

package/README.md

@@ -1,158 +1,185 @@
 # fbi-proxy
 
-FBI Proxy is a super easy way to turn your local network over https.
+FBI Proxy is a super easy way to turn your local network over HTTPS with intelligent domain routing.
 
 ## Quick Start
 
 ```bash
-# Build the Rust proxy (production)
-npm run build-proxy
+# Install dependencies
+bun install
 
-# Start the proxy system
-npm start
+# Build and start the proxy system
+bun run start
 
 # Development mode with auto-reload
-npm run dev
+bun run dev
 ```
 
 ## Build Scripts
 
-### Rust Proxy Build Commands:
+### Available Commands:
 
 ```bash
-# Production build (optimized)
-npm run build-proxy
+# Build TypeScript CLI
+bun run build:ts
 
-# Development build (faster compilation)
-npm run build-proxy-dev
+# Build Rust proxy binary
+bun run build:rs
 
-# Windows-specific build (uses build-windows.bat)
-npm run build-proxy-windows
+# Full build (both TypeScript and Rust)
+bun run build
 
-# Check code without building
-npm run check-proxy
+# Development with hot reload
+bun run dev
 
-# Clean build artifacts
-npm run clean-proxy
-
-# Run tests
-npm run test-proxy
-
-# Format code
-npm run fmt-proxy
-
-# Run linter
-npm run clippy-proxy
-
-# Run proxy directly (for testing)
-npm run run-proxy
+# Production start
+bun run start
 ```
 
-### Combined Commands:
-
-```bash
-# Build and run (development)
-npm run proxy:dev
+## Architecture
 
-# Build and run (production)
-npm run proxy:prod
+The FBI Proxy consists of three main components:
 
-# Full build (includes pre-build checks)
-npm run build
-```
+- **TypeScript CLI** (`ts/cli.ts`): Orchestrates the entire system, manages Caddy and Rust proxy processes
+- **Rust Proxy Server** (`proxy.rs`): High-performance HTTP/WebSocket proxy using Hyper framework
+- **Caddy Server**: Handles TLS termination, SSL certificates, and domain routing
 
-## Architecture
+### How It Works
 
-- **TypeScript CLI** (`src/cli.ts`): Orchestrates Caddy and Rust proxy
-- **Rust Proxy** (`rs/proxy.rs`): High-performance HTTP/WebSocket proxy using Hyper
-- **Caddy Server**: Handles TLS termination and domain routing
+1. **CLI** downloads/manages Caddy binary and builds the Rust proxy
+2. **Caddy** receives incoming HTTPS requests and forwards them to the Rust proxy
+3. **Rust Proxy** intelligently routes requests based on hostname patterns
 
 ## Development Workflow
 
 ### First Time Setup:
 
 ```bash
-# 1. Install dependencies
-npm install
+# 1. Install dependencies (requires Bun)
+bun install
 
-# 2. Build the Rust proxy
-npm run build-proxy
-
-# 3. Start development
-npm run dev
+# 2. Start development (automatically builds and runs)
+bun run dev
 ```
 
 ### Daily Development:
 
 ```bash
-# Quick development cycle
-npm run proxy:dev
+# Development with hot reload for both Caddy and Rust
+bun run dev
 
-# Or step by step:
-npm run build-proxy-dev  # Fast Rust build
-npm run dev              # Start with auto-reload
+# Or run individual components:
+bun run dev:caddy    # Start Caddy with file watching
+bun run dev:rs       # Start Rust proxy with bacon (auto-rebuild)
 ```
 
-### Before Committing:
+### Production Deployment:
 
 ```bash
-npm run fmt-proxy        # Format Rust code
-npm run clippy-proxy     # Check Rust linting
-npm run check-proxy      # Verify compilation
-npm run test-proxy       # Run tests
+bun run build       # Build optimized binaries
+bun run start       # Start production services
 ```
 
-### Production Build:
+## Prerequisites
 
-```bash
-npm run build           # Full optimized build
-npm run proxy:prod      # Build and run production
-```
+- **Bun**: JavaScript runtime and package manager (install from https://bun.sh/)
+- **Rust**: For building the proxy binary (install from https://rustup.rs/)
+- **Caddy**: Automatically downloaded by the CLI if not found
 
-## Prerequisites
+## Routing Features
+
+The FBI Proxy supports intelligent hostname-based routing with the following patterns:
+
+### 1. Port Forwarding
+
+- `https://3000.fbi.com` → `http://localhost:3000`
+- `https://8080.fbi.com` → `http://localhost:8080`
 
-- **Rust**: Install from https://rustup.rs/
-- **Caddy**: Web server for TLS termination
-- **Bun**: Runtime for TypeScript CLI
+### 2. Host--Port Forwarding
 
-## feats
+- `https://localhost--3000.fbi.com` → `http://localhost:3000`
+- `https://myserver--8080.fbi.com` → `http://myserver:8080`
 
-1. Port Forwarder, https://[port].fbi.com proxies to http://localhost:[port]
-2. Host Forwarder, https://[*].[host].fbi.com proxies to [host] with url https://[*].fbi.com
-3. Host:Port forwarder https://[host]--[port].fbi.com proxies to http://[host]:[port]
-4. Configurable host alias
+### 3. Subdomain Hoisting
 
-## ...
+- `https://api.myserver.fbi.com` → `http://myserver:80` (with Host: `api`)
+- `https://admin.localhost.fbi.com` → `http://localhost:80` (with Host: `admin`)
 
-configurable local Proxy generator
+### 4. Direct Host Forwarding
 
-Environment Defaults:
+- `https://myserver.fbi.com` → `http://myserver:80`
+- `https://localhost.fbi.com` → `http://localhost:80`
+
+### WebSocket Support
+
+All routing patterns support WebSocket connections with automatic upgrade handling.
+
+## Configuration
+
+### Environment Variables
 
 ```env
-LOCALHOST="fbi.com"
-SERVICES="localhost:5600"
+FBIHOST="fbi.com"           # Default domain (configurable via --fbihost)
+FBIPROXY_PORT="24306"       # Internal proxy port (auto-assigned)
 ```
 
-activitywatch=3000
-activitywatch=3000
-activitywatch=3000
-activitywatch=3000
+### CLI Options
 
+```bash
+bun run ts/cli.ts --help
+
+Options:
+  --help          Show help message
+  --fbihost       Set the FBI host (default: fbi.com)
 ```
 
-# https://activitywatch.fbi.com -> localhost:5600
-activitywatch: :5600
+## Service Configuration Examples
 
-# https://aw.fbi.com -> localhost:5600
-aw: :5600
+Create custom service mappings by modifying the routing logic or using the built-in patterns:
 
-# https://calibre.fbi.com -> localhost:7250
-calibre: :7250
+```bash
+# Direct port access
+https://3000.fbi.com        # → localhost:3000
+https://5173.fbi.com        # → localhost:5173 (Vite dev server)
+https://8000.fbi.com        # → localhost:8000 (VS Code server)
+
+# Named services with custom ports
+https://api--3001.fbi.com   # → api:3001
+https://db--5432.fbi.com    # → db:5432
+
+# Subdomain routing
+# Subdomain routing
+https://admin.app.fbi.com   # → app:80 with Host: admin
+https://v2.api.fbi.com      # → api:80 with Host: v2
+```
 
-# https://everything.fbi.com -> localhost:2489
-everything: :2489
+## Technical Details
 
-# https://vscode.fbi.com -> localhost:8000
-vscode: :8000
+### Rust Proxy Implementation (`proxy.rs`)
 
-```
+The Rust proxy server implements the following routing logic:
+
+1. **Number Host Detection**: Pure numeric hosts (e.g., `3000`) route to `localhost:3000`
+2. **Double-Dash Parsing**: `host--port` format routes to `host:port`
+3. **Subdomain Hoisting**: Multi-level domains route to the root domain with subdomain as Host header
+4. **Default Port 80**: Simple hostnames default to port 80
+
+### TypeScript CLI (`ts/cli.ts`)
+
+The CLI manages:
+
+- Binary discovery and building (Rust proxy, Caddy download)
+- Process orchestration with proper signal handling
+- Port management and environment variable passing
+- Hot reloading during development
+
+### Caddy Configuration (`Caddyfile`)
+
+- Automatic HTTPS with on-demand TLS certificates
+- Regex-based host header matching
+- Reverse proxy configuration with header manipulation
+- Support for wildcard subdomain routing
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details

package/package.json

@@ -7,6 +7,8 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^9.2.0",
     "@types/bun": "latest",
+    "@types/minimist": "^1.2.5",
+    "semantic-release-cargo": "^2.4.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.2",
     "prettier": "^3.6.2",
@@ -15,27 +17,48 @@
   "peerDependencies": {
     "typescript": "^5"
   },
+  "files": [
+    "release",
+    "rs",
+    "ts",
+    "dist",
+    "Caddyfile"
+  ],
   "dependencies": {
-    "@types/minimist": "^1.2.5",
+    "@snomiao/caddy-baron": "^3.0.4",
+    "bun": "^1.2.19",
     "caddy-baron": "^3.0.2",
+    "from-node-stream": "^0.1.0",
     "get-port": "^7.1.0",
     "hot-memo": "^1.1.1",
     "minimist": "^1.2.8",
+    "npm-run-all": "^4.1.5",
     "phpdie": "^1.7.0",
-    "rustup": "^1.0.10"
+    "promise-all-properties": "^5.0.0",
+    "sflow": "^1.23.0",
+    "ts-toolbelt": "^9.6.0",
+    "tsa-composer": "^1.0.0",
+    "zx": "^8.7.2"
   },
   "scripts": {
     "build-cli": "bun build ts/cli.ts --outdir dist",
-    "build": "bun run build:rs && bun run build:ts",
-    "build:ts": "bun build ./ts/*.ts --outdir dist --target node --declaration",
-    "build:rs": "cd rs && cargo build --release",
-    "dev": "bun --hot ts/cli.ts",
+    "build": "run-p build:rs build:ts build:js",
+    "build:ts": "tsc",
+    "build:js": "bun build ./ts/cli.ts --outdir dist --target node",
+    "build:rs": "cargo build --release",
+    "dev": "run-p dev:caddy dev:rs",
+    "dev:caddy": "./caddy run --watch",
+    "dev:ts": "bun --hot ts/cli.ts --dev",
+    "dev:rs": "cd rs && bacon run",
+    "dev:rs-watch": "cd rs && cargo watch -x run",
     "start": "bun ts/cli.ts",
-    "prepare": "husky"
+    "start:js": "node dist/cli.js",
+    "start:caddy": "./caddy run",
+    "start:rs": "./target/release/fbi-proxy",
+    "prepare": "husky && bunx rustup && bacon --version || cargo install bacon"
   },
   "lint-staged": {
     "*.{ts,js}": [
-      "bun tsc --noEmit",
       "bun --bun prettier --write"
     ],
     "*.{json,md,yml,yaml}": [
@@ -43,7 +66,7 @@
     ]
   },
   "bin": {
-    "fbi-proxy": "ts/cli.ts"
+    "fbi-proxy": "dist/cli.js"
   },
-  "version": "1.2.0"
+  "version": "1.4.0"
 }

package/ts/buildFbiProxy.ts

@@ -0,0 +1,34 @@
+import fsp from "fs/promises";
+import { existsSync } from "fs";
+import { getProxyFilename } from "./getProxyFilename";
+import { copyFile } from "fs/promises";
+import { $ } from "./dRun";
+import { mkdir } from "fs/promises";
+
+if (import.meta.main) {
+  await buildFbiProxy();
+}
+
+export async function buildFbiProxy({ rebuild = false } = {}) {
+  const isWin = process.platform === "win32";
+  const binaryName = getProxyFilename();
+
+  const release = "./release/" + binaryName;
+  const built = `./target/release/fbi-proxy${isWin ? ".exe" : ""}`;
+
+  // return built if exists
+  if (!rebuild && existsSync(built)) {
+    return built;
+  }
+
+  // return release if exists
+  if (!rebuild && existsSync(release)) return release;
+
+  // build and return built target
+  await $`cargo build --release`;
+  if (existsSync(built)) return built;
+
+  throw new Error(
+    "Oops, failed to build fbi-proxy binary. Please check your Rust setup.",
+  );
+}

package/ts/cli.ts

@@ -1,140 +1,83 @@
 #!/usr/bin/env bun
 import getPort from "get-port";
-import minimist from "minimist";
 import hotMemo from "hot-memo";
-import { exec } from "child_process";
+import minimist from "minimist";
 import path from "path";
-import { exists } from "fs/promises";
-import { existsSync } from "fs";
-import { DIE } from "phpdie";
+import promiseAllProperties from "promise-all-properties";
+import { buildFbiProxy } from "./buildFbiProxy";
+import { $ } from "./dRun";
+import { downloadCaddy } from "./downloadCaddy";
 
-// guide to install caddy
-if (!(await Bun.$`caddy --version`.text().catch(() => ""))) {
-  console.error("Caddy is not installed. Please install Caddy first");
-  console.error(`For windows, try running:\n    choco install caddy\n`);
-  console.error(`For linux, try running:\n    sudo apt install caddy\n`);
-  process.exit(1);
-}
+process.chdir(path.resolve(__dirname, "..")); // Change to project root directory
 
-const getProxyPath = () => {
-  const root = Bun.fileURLToPath(import.meta.url) + "../";
-  const ciFilename =
-    {
-      "darwin-arm64": "fbi-proxy-darwin",
-      "darwin-x64": "fbi-proxy-darwin",
-      "linux-arm64": "fbi-proxy-linux-arm64",
-      "linux-x64": "fbi-proxy-linux-x64",
-      "linux-x86_64": "fbi-proxy-linux-x64",
-      "win32-arm64": "fbi-proxy-windows-arm64.exe",
-      "win32-x64": "fbi-proxy-windows-x64.exe",
-    }[process.platform + "-" + process.arch] || "fbi-proxy-linux-x64";
+console.log("Preparing Binaries");
 
-  return [path.join(root, "rs/target/release", ciFilename),
-  path.join(root, "rs/target/release", 'proxy'),
-  path.join(root, "rs/target/release", 'proxy.exe'),
-  ].find((e) =>
-    existsSync(e)
-  ) || DIE('Proxy binary not found. Please build the Rust proxy server first using `cargo build --release`');
-};
+const { proxy, caddy } = await promiseAllProperties({
+  proxy: buildFbiProxy(),
+  caddy: downloadCaddy(),
+});
+
+console.log("Running fbi-proxy", JSON.stringify({ caddy, proxy }));
 
 // assume caddy is installed, launch proxy server now
 const argv = minimist(process.argv.slice(2), {
   default: {
     dev: false,
     d: false,
-    tls: "internal", // default to internal TLS
+    fbihost: "fbi.com", // Default FBI host
   },
   alias: {
     dev: "d",
-    tls: "t",
   },
+  boolean: ["dev", "d", "help"],
 });
-console.log(argv);
+// console.log(argv);
 if (argv.help) {
   console.log(`Usage: fbi-proxy [options]
 Options:
-  --dev, -d       Enable development mode
-  --tls, -t       Set TLS mode (internal|external)
   --help          Show this help message
+  --fbihost       Set the FBI host (default: fbi.com)
 `);
   process.exit(0);
 }
 
-const isDev = argv.dev || argv.d || false;
-const PROXY_PORT = String(await getPort({ port: 24306 }));
+const FBIHOST = argv.fbihost || "fbi.com"; // Default FBI host
+const FBIPROXY_PORT = String(await getPort({ port: 24306 }));
 const proxyProcess = await hotMemo(async () => {
   console.log("Starting Rust proxy server");
+  const p = $.opt({
+    env: {
+      ...process.env,
+      FBIPROXY_PORT, // Rust proxy server port
+    },
+  })`${proxy}`.process;
 
-  // TODO: in production, build and start the Rust proxy server
-  //       using `cargo build --release` and then run the binary
-  const p = await (async () => {
-    if (isDev) {
-      // TODO: consider switch to bacon, cargo install bacon
-      // in dev mode, use cargo watch to run the Rust proxy server
-      const p = exec(`cargo watch -x "run --bin proxy"`, {
-        env: {
-          ...process.env,
-          PROXY_PORT,
-        },
-        cwd: path.join(__dirname, "../rs"),
-      });
-      return p;
-    }
-
-    const proxyPath = getProxyPath()
-    if (!(await exists(proxyPath).catch(() => false))) {
-      console.error("Proxy binary not found at " + proxyPath);
-      console.error(
-        "Please build the Rust proxy server first using `cargo build --release`"
-      );
-      process.exit(1);
-    }
-    const p = exec(proxyPath, {
-      env: {
-        ...process.env,
-        PROXY_PORT, // Rust proxy server port
-      },
-    });
-    return p;
-  })();
-
-  p.stdout?.pipe(process.stdout, { end: false });
-  p.stderr?.pipe(process.stderr, { end: false });
   p.on("exit", (code) => {
     console.log(`Proxy server exited with code ${code}`);
     process.exit(code || 0);
   });
-
-  console.log(`Rust proxy server started on port ${PROXY_PORT}`);
   return p;
 });
 
 const caddyProcess = await hotMemo(async () => {
-  const Caddyfile = path.join(__dirname, "../Caddyfile");
-  if (!(await exists(Caddyfile).catch(() => false))) {
-    console.error("Caddyfile not found at " + Caddyfile);
-    console.error(
-      "Please create a Caddyfile in the root directory of the project."
-    );
-    process.exit(1);
-  }
-  console.log("Starting Caddy");
-  const p = exec(`caddy run ${isDev ? "--watch" : ""} --config ${Caddyfile}`, {
+  const p = $.opt({
     env: {
       ...process.env,
-      PROXY_PORT, // Rust proxy server port
-      TLS: argv.tls || "internal", // Use internal TLS by default, or set via command line argument
+      FBIPROXY_PORT, // Rust proxy server port
+      FBIHOST,
     },
-    cwd: path.dirname(Caddyfile),
+  })`${caddy} run`.process;
+  p.on("exit", (code) => {
+    console.log(`Caddy exited with code ${code}`);
+    process.exit(code || 0);
   });
-  // p.stdout?.pipe(process.stdout, { end: false });
-  // p.stderr?.pipe(process.stderr, { end: false });
-  p.on("exit", (code) => process.exit(code || 0));
-  console.log("Caddy started with config at " + Caddyfile);
   return p;
 });
 
 console.log("all done");
+// show process pids
+console.log(`Proxy server PID: ${proxyProcess.pid}`);
+console.log(`Caddy server PID: ${caddyProcess.pid}`);
 
 const exit = () => {
   console.log("Shutting down...");