fbi-proxy 1.4.0 → 1.5.0

package/README.md

@@ -1,184 +1,67 @@
 # fbi-proxy
 
-FBI Proxy is a super easy way to turn your local network over HTTPS with intelligent domain routing.
+FBI-Proxy provides easy HTTPS access to your local services with intelligent domain routing.
 
-## Quick Start
+## Usage
 
-```bash
-# Install dependencies
-bun install
+```sh
+# launch
+bunx fbi-proxy
 
-# Build and start the proxy system
-bun run start
+# expose to LAN
+bunx fbi-proxy --host 0.0.0.0 --port=2432
 
-# Development mode with auto-reload
-bun run dev
-```
+# with caddy, forwarding *.fbi.com
+bunx fbi-proxy --caddy=fbi.com
 
-## Build Scripts
+# or
+docker start
+```
 
-### Available Commands:
+### Routing Examples
 
 ```bash
-# Build TypeScript CLI
-bun run build:ts
-
-# Build Rust proxy binary
-bun run build:rs
+# Port forwarding
+https://3000.fbi.com        → localhost:3000
+https://8080.fbi.com        → localhost:8080
 
-# Full build (both TypeScript and Rust)
-bun run build
+# Host--Port forwarding
+https://api--3001.fbi.com   → api:3001
+https://db--5432.fbi.com    → db:5432
 
-# Development with hot reload
-bun run dev
+# Subdomain routing (with Host header)
+https://admin.app.fbi.com   → app:80 (Host: admin)
+https://v2.api.fbi.com      → api:80 (Host: v2)
 
-# Production start
-bun run start
+# Direct host forwarding
+https://myserver.fbi.com    → myserver:80
 ```
 
-## Architecture
-
-The FBI Proxy consists of three main components:
-
-- **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
-
-### How It Works
+WebSocket connections are supported for all patterns.
 
-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:
+## Development
 
 ```bash
-# 1. Install dependencies (requires Bun)
+# Install dependencies
 bun install
 
-# 2. Start development (automatically builds and runs)
+# Start development
 bun run dev
-```
-
-### Daily Development:
-
-```bash
-# Development with hot reload for both Caddy and Rust
-bun run dev
-
-# Or run individual components:
-bun run dev:caddy    # Start Caddy with file watching
-bun run dev:rs       # Start Rust proxy with bacon (auto-rebuild)
-```
-
-### Production Deployment:
-
-```bash
-bun run build       # Build optimized binaries
-bun run start       # Start production services
-```
-
-## Prerequisites
-
-- **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
-
-## 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`
-
-### 2. Host--Port Forwarding
-
-- `https://localhost--3000.fbi.com` → `http://localhost:3000`
-- `https://myserver--8080.fbi.com` → `http://myserver:8080`
-
-### 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`)
-
-### 4. Direct Host Forwarding
-
-- `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
-FBIHOST="fbi.com"           # Default domain (configurable via --fbihost)
-FBIPROXY_PORT="24306"       # Internal proxy port (auto-assigned)
-```
-
-### CLI Options
-
-```bash
-bun run ts/cli.ts --help
-
-Options:
-  --help          Show help message
-  --fbihost       Set the FBI host (default: fbi.com)
-```
-
-## Service Configuration Examples
-
-Create custom service mappings by modifying the routing logic or using the built-in patterns:
-
-```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
+# Or production
+bun run build && bun run start
 ```
 
-## Technical Details
-
-### 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:
+### Prerequisites
 
-- Binary discovery and building (Rust proxy, Caddy download)
-- Process orchestration with proper signal handling
-- Port management and environment variable passing
-- Hot reloading during development
+- **Bun**: https://bun.sh/
+- **Rust**: https://rustup.rs/
+- **Caddy**: Auto-downloaded if not found
 
-### Caddy Configuration (`Caddyfile`)
+### Configuration
 
-- Automatic HTTPS with on-demand TLS certificates
-- Regex-based host header matching
-- Reverse proxy configuration with header manipulation
-- Support for wildcard subdomain routing
+- Default domain: `fbi.com` (change with `--fbihost`)
+- Internal proxy port: Auto-assigned to `FBIPROXY_PORT`
 
 ## License
 

package/package.json

@@ -15,6 +15,7 @@
     "semantic-release": "^22.0.0"
   },
   "peerDependencies": {
+    "@snomiao/caddy-baron": "^3.0.4",
     "typescript": "^5"
   },
   "files": [
@@ -24,10 +25,13 @@
     "dist",
     "Caddyfile"
   ],
+  "trustedDependencies": [
+    "@radically-straightforward/caddy"
+  ],
   "dependencies": {
-    "@snomiao/caddy-baron": "^3.0.4",
+    "@radically-straightforward/caddy": "^2.0.6",
     "bun": "^1.2.19",
-    "caddy-baron": "^3.0.2",
+    "execa": "^9.6.0",
     "from-node-stream": "^0.1.0",
     "get-port": "^7.1.0",
     "hot-memo": "^1.1.1",
@@ -38,6 +42,7 @@
     "sflow": "^1.23.0",
     "ts-toolbelt": "^9.6.0",
     "tsa-composer": "^1.0.0",
+    "yargs": "^17.7.2",
     "zx": "^8.7.2"
   },
   "scripts": {
@@ -55,7 +60,7 @@
     "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"
+    "prepare": "husky"
   },
   "lint-staged": {
     "*.{ts,js}": [
@@ -68,5 +73,5 @@
   "bin": {
     "fbi-proxy": "dist/cli.js"
   },
-  "version": "1.4.0"
+  "version": "1.5.0"
 }

package/ts/buildFbiProxy.ts

@@ -2,7 +2,7 @@ import fsp from "fs/promises";
 import { existsSync } from "fs";
 import { getProxyFilename } from "./getProxyFilename";
 import { copyFile } from "fs/promises";
-import { $ } from "./dRun";
+import { $ } from "./dSpawn";
 import { mkdir } from "fs/promises";
 
 if (import.meta.main) {

package/ts/cli.ts

@@ -1,49 +1,43 @@
 #!/usr/bin/env bun
 import getPort from "get-port";
 import hotMemo from "hot-memo";
-import minimist from "minimist";
 import path from "path";
-import promiseAllProperties from "promise-all-properties";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import { buildFbiProxy } from "./buildFbiProxy";
-import { $ } from "./dRun";
+import { $ } from "./dSpawn";
 import { downloadCaddy } from "./downloadCaddy";
+import { execa } from "execa";
 
 process.chdir(path.resolve(__dirname, "..")); // Change to project root directory
 
-console.log("Preparing Binaries");
-
-const { proxy, caddy } = await promiseAllProperties({
-  proxy: buildFbiProxy(),
-  caddy: downloadCaddy(),
-});
+// Parse command line arguments with yargs
+const argv = await yargs(hideBin(process.argv))
+  .option("fbihost", {
+    type: "string",
+    default: "fbi.com",
+    description: "Set the FBI host",
+  })
+  .option("caddy", {
+    type: "boolean",
+    default: false,
+    description: "Start Caddy server",
+  })
+  .option("dev", {
+    alias: "d",
+    type: "boolean",
+    default: false,
+    description: "Run in development mode",
+  })
+  .help().argv;
 
-console.log("Running fbi-proxy", JSON.stringify({ caddy, proxy }));
+console.log("Preparing Binaries");
 
-// assume caddy is installed, launch proxy server now
-const argv = minimist(process.argv.slice(2), {
-  default: {
-    dev: false,
-    d: false,
-    fbihost: "fbi.com", // Default FBI host
-  },
-  alias: {
-    dev: "d",
-  },
-  boolean: ["dev", "d", "help"],
-});
-// console.log(argv);
-if (argv.help) {
-  console.log(`Usage: fbi-proxy [options]
-Options:
-  --help          Show this help message
-  --fbihost       Set the FBI host (default: fbi.com)
-`);
-  process.exit(0);
-}
+const FBIHOST = argv.fbihost;
+const FBIPROXY_PORT = String(await getPort({ port: 2432 }));
 
-const FBIHOST = argv.fbihost || "fbi.com"; // Default FBI host
-const FBIPROXY_PORT = String(await getPort({ port: 24306 }));
 const proxyProcess = await hotMemo(async () => {
+  const proxy = await buildFbiProxy();
   console.log("Starting Rust proxy server");
   const p = $.opt({
     env: {
@@ -59,25 +53,35 @@ const proxyProcess = await hotMemo(async () => {
   return p;
 });
 
-const caddyProcess = await hotMemo(async () => {
-  const p = $.opt({
-    env: {
-      ...process.env,
-      FBIPROXY_PORT, // Rust proxy server port
-      FBIHOST,
-    },
-  })`${caddy} run`.process;
-  p.on("exit", (code) => {
-    console.log(`Caddy exited with code ${code}`);
-    process.exit(code || 0);
+let caddyProcess: any = null;
+
+// Only start Caddy if --caddy flag is passed
+if (argv.caddy) {
+  const caddy = await downloadCaddy();
+  caddyProcess = await hotMemo(async () => {
+    const p = $.opt({
+      env: {
+        ...process.env,
+        FBIPROXY_PORT, // Rust proxy server port
+        FBIHOST,
+      },
+    })`${caddy} run`.process;
+    p.on("exit", (code) => {
+      console.log(`Caddy exited with code ${code}`);
+      process.exit(code || 0);
+    });
+    return p;
   });
-  return p;
-});
+}
 
 console.log("all done");
 // show process pids
 console.log(`Proxy server PID: ${proxyProcess.pid}`);
-console.log(`Caddy server PID: ${caddyProcess.pid}`);
+if (caddyProcess) {
+  console.log(`Caddy server PID: ${caddyProcess.pid}`);
+} else {
+  console.log("Caddy server not started (use --caddy to start it)");
+}
 
 const exit = () => {
   console.log("Shutting down...");

package/ts/{dRun.ts → dSpawn.ts}

@@ -15,17 +15,18 @@ type DRunProc = Promise<{
   process: ChildProcess;
 };
 
-const dRun = ({
+const dSpawn = ({
   cwd = process.cwd(),
   env = process.env as Record<string, string>,
 } = {}) =>
   tsaComposer(
-    (s: string | { raw: string }) =>
-      typeof s === "string"
+    // slot is un dividable
+    (slot: string | { raw: string }) =>
+      typeof slot === "string"
         ? {
-            raw: String(s), // todo: escape quotes
+            raw: String(slot), // todo: escape quotes
           }
-        : s,
+        : slot,
     (...slots): DRunProc => {
       try {
         // TODO: parse slots for quotes
@@ -106,7 +107,7 @@ const dRun = ({
     },
   );
 
-export const $ = Object.assign(dRun(), {
-  opt: dRun,
-  cwd: (path: string) => dRun({ cwd: path }),
+export const $ = Object.assign(dSpawn(), {
+  opt: dSpawn,
+  cwd: (path: string) => dSpawn({ cwd: path }),
 });

package/ts/downloadCaddy.ts

@@ -1,31 +1,24 @@
 import { existsSync } from "fs";
-import fsp from "fs/promises";
-import { $ } from "./dRun";
+import { $ } from "./dSpawn";
 
-export const downloadCaddy = async () => {
-  // use pwdCaddy if already downloaded
-  const pwdCaddy = "./caddy";
+if (import.meta.main) {
+  // if this file is run directly, download caddy
+  const caddy = await downloadCaddy();
+  console.log(`Caddy downloaded to: ${caddy}`);
+  process.exit(0);
+}
 
-  // if ./caddy exists in pwd, return it
+export async function downloadCaddy() {
+  // use pwdCaddy if already downloaded
+  const pwdCaddy = "./node_modules/.bin/caddy";
   if (existsSync(pwdCaddy)) return pwdCaddy;
 
-  // or use system caddy if installed, run `caddy --version` to check
+  // // or use system caddy if installed, run `caddy --version` to check
   if (await $`caddy --version`.catch(() => false)) {
     return "caddy";
   }
 
-  // or if system caddy is not installed, download caddy using caddy-baron
-  if (!existsSync(pwdCaddy)) {
-    // download latest caddy to ./caddy
-    console.log("Downloading Caddy...");
-    // @ts-ignore
-    await import("../node_modules/caddy-baron/index.mjs");
-
-    if (!existsSync(pwdCaddy))
-      throw new Error(
-        "Failed to download Caddy. Please install Caddy manually or check your network connection.",
-      );
-  }
-
-  return pwdCaddy;
-};
+  throw new Error(
+    "Failed to download Caddy. Please install Caddy manually or check your network connection.",
+  );
+}