npm - fbi-proxy - Versions diffs - 1.0.0 - Mend

fbi-proxy 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/.gitattributes +31 -0
package/.github/workflows/release.yml +112 -0
package/.releaserc.json +37 -0
package/CHANGELOG.md +17 -0
package/Caddyfile +19 -0
package/Dockerfile +38 -0
package/INSTALL.md +161 -0
package/LICENSE +21 -0
package/PINGORA_PROXY.md +127 -0
package/README.md +158 -0
package/RUST_PROXY.md +85 -0
package/build-proxy.bat +15 -0
package/build-proxy.sh +15 -0
package/bun.lock +1238 -0
package/docker-compose.yml +9 -0
package/package.json +36 -0
package/release/proxy-linux-arm64/proxy-linux-arm64 +0 -0
package/release/proxy-linux-x64/proxy-linux-x64 +0 -0
package/release/proxy-macos-arm64/proxy-macos-arm64 +0 -0
package/release/proxy-macos-x64/proxy-macos-x64 +0 -0
package/release/proxy-windows-arm64.exe/proxy-windows-arm64.exe +0 -0
package/release/proxy-windows-x64.exe/proxy-windows-x64.exe +0 -0
package/release-flat/proxy-linux-arm64 +0 -0
package/release-flat/proxy-linux-x64 +0 -0
package/release-flat/proxy-macos-arm64 +0 -0
package/release-flat/proxy-macos-x64 +0 -0
package/release-flat/proxy-windows-arm64.exe +0 -0
package/release-flat/proxy-windows-x64.exe +0 -0
package/rs/.cargo/config.toml +5 -0
package/rs/Cargo.lock +1220 -0
package/rs/Cargo.toml +19 -0
package/rs/build-windows.bat +60 -0
package/rs/proxy.rs +248 -0
package/ts/cli.ts +148 -0
package/tsconfig.json +22 -0

package/rs/Cargo.toml ADDED Viewed

@@ -0,0 +1,19 @@
+[package]
+name = "fbi-proxy"
+version = "0.1.0"
+edition = "2021"
+[[bin]]
+name = "proxy"
+path = "proxy.rs"
+[dependencies]
+# Using simpler dependencies that build reliably on Windows
+hyper = { version = "0.14", features = ["full"] }
+hyper-tungstenite = "0.11"
+tokio = { version = "1.0", features = ["full"] }
+tokio-tungstenite = "0.20"
+futures-util = "0.3"
+regex = "1.0"
+env_logger = "0.10"
+log = "0.4"

package/rs/build-windows.bat ADDED Viewed

@@ -0,0 +1,60 @@
+@echo off
+echo Installing required dependencies for Windows build...
+echo.
+echo Checking for required tools...
+where cmake >nul 2>&1
+if %errorlevel% neq 0 (
+    echo ❌ CMake not found. Installing via chocolatey...
+    where choco >nul 2>&1
+    if %errorlevel% neq 0 (
+        echo Please install Chocolatey first: https://chocolatey.org/install
+        echo Or install CMake manually: https://cmake.org/download/
+        pause
+        exit /b 1
+    )
+    choco install cmake -y
+) else (
+    echo ✅ CMake found
+)
+where perl >nul 2>&1
+if %errorlevel% neq 0 (
+    echo ❌ Perl not found. Installing Strawberry Perl...
+    where choco >nul 2>&1
+    if %errorlevel% neq 0 (
+        echo Please install Chocolatey first or install Strawberry Perl manually
+        echo Strawberry Perl: https://strawberryperl.com/
+        pause
+        exit /b 1
+    )
+    choco install strawberryperl -y
+) else (
+    echo ✅ Perl found
+)
+echo.
+echo Setting environment variables for Windows build...
+set OPENSSL_NO_VENDOR=1
+set CMAKE_GENERATOR=Visual Studio 17 2022
+echo.
+echo Building Rust proxy with Pingora...
+cargo build --release
+if %errorlevel% equ 0 (
+    echo.
+    echo ✅ Build successful!
+    echo Binary location: target\release\proxy.exe
+) else (
+    echo.
+    echo ❌ Build failed. Check the error messages above.
+    echo.
+    echo Common solutions:
+    echo 1. Restart your terminal after installing dependencies
+    echo 2. Make sure Visual Studio Build Tools are installed
+    echo 3. Try: cargo clean && cargo build --release
+)
+pause

package/rs/proxy.rs ADDED Viewed

@@ -0,0 +1,248 @@
+use futures_util::{SinkExt, StreamExt};
+use hyper::header::{HeaderValue, HOST};
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Client, Request, Response, Server, StatusCode, Uri};
+use hyper_tungstenite::{HyperWebsocket, WebSocketStream};
+use log::{error, info};
+use regex::Regex;
+use std::convert::Infallible;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio_tungstenite::connect_async;
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
+pub struct FBIProxy {
+    client: Client<hyper::client::HttpConnector>,
+    port_regex: Regex,
+}
+impl FBIProxy {
+    pub fn new() -> Self {
+        Self {
+            client: Client::new(),
+            port_regex: Regex::new(r"--(\d+).*$").unwrap(),
+        }
+    }
+    fn extract_target_host(&self, host_header: &str) -> String {
+        self.port_regex.replace(host_header, ":$1").to_string()
+    }
+    pub async fn handle_request(&self, mut req: Request<Body>) -> Result<Response<Body>, BoxError> {
+        // Extract host from headers and process port encoding
+        let host_header = req
+            .headers()
+            .get(HOST)
+            .and_then(|h| h.to_str().ok())
+            .unwrap_or("localhost");
+        let target_host = self.extract_target_host(host_header);
+        info!("Proxying {} {} -> {}", req.method(), req.uri(), target_host);
+        // Handle WebSocket upgrade requests
+        if hyper_tungstenite::is_upgrade_request(&req) {
+            return self.handle_websocket_upgrade(req, &target_host).await;
+        }
+        // Build target URL for HTTP requests
+        let uri = req.uri();
+        let target_url = format!(
+            "http://{}{}",
+            target_host,
+            uri.path_and_query().map(|pq| pq.as_str()).unwrap_or("/")
+        );
+        let target_uri: Uri = target_url.parse()?;
+        // Update request URI and headers
+        *req.uri_mut() = target_uri;
+        req.headers_mut()
+            .insert(HOST, HeaderValue::from_str("localhost")?);
+        req.headers_mut().remove("content-encoding");
+        // Forward the request
+        match self.client.request(req).await {
+            Ok(mut response) => {
+                // Remove content-encoding header from response
+                response.headers_mut().remove("content-encoding");
+                info!("HTTP {} -> {}", target_url, response.status());
+                Ok(response)
+            }
+            Err(e) => {
+                error!("Proxy error for {}: {}", target_url, e);
+                Ok(Response::builder()
+                    .status(StatusCode::BAD_GATEWAY)
+                    .body(Body::from("Gateway Error"))?)
+            }
+        }
+    }
+    async fn handle_websocket_upgrade(
+        &self,
+        req: Request<Body>,
+        target_host: &str,
+    ) -> Result<Response<Body>, BoxError> {
+        let uri = req.uri();
+        let ws_url = format!(
+            "ws://{}{}",
+            target_host,
+            uri.path_and_query().map(|pq| pq.as_str()).unwrap_or("/")
+        );
+        info!("WebSocket upgrade to: {}", ws_url);
+        // Upgrade the HTTP connection to WebSocket
+        let (response, websocket) = hyper_tungstenite::upgrade(req, None)?;
+        // Connect to upstream WebSocket
+        info!("Connecting to upstream WebSocket: {}", ws_url);
+        let (upstream_ws, _) = match connect_async(&ws_url).await {
+            Ok(ws) => ws,
+            Err(e) => {
+                error!("Failed to connect to upstream WebSocket {}: {}", ws_url, e);
+                return Ok(Response::builder()
+                    .status(StatusCode::BAD_GATEWAY)
+                    .body(Body::from("WebSocket connection failed"))?);
+            }
+        };
+        // Spawn task to handle WebSocket forwarding
+        info!("Starting WebSocket forwarding for: {}", ws_url);
+        let ws_url_clone = ws_url.clone();
+        tokio::spawn(async move {
+            if let Err(e) = handle_websocket_forwarding(websocket, upstream_ws).await {
+                error!("WebSocket forwarding error for {}: {}", ws_url_clone, e);
+            }
+        });
+        info!("WebSocket upgrade successful for: {}", ws_url);
+        Ok(response)
+    }
+}
+async fn handle_websocket_forwarding(
+    websocket: HyperWebsocket,
+    upstream_ws: WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>,
+) -> Result<(), BoxError> {
+    // Get the client WebSocket stream
+    let client_ws = websocket.await?;
+    let (mut client_sink, mut client_stream) = client_ws.split();
+    let (mut upstream_sink, mut upstream_stream) = upstream_ws.split();
+    info!("WebSocket connection established, starting bidirectional forwarding");
+    // Forward messages from client to upstream
+    let client_to_upstream = async {
+        while let Some(msg) = client_stream.next().await {
+            match msg {
+                Ok(msg) => {
+                    info!("Client -> Upstream: {:?}", msg);
+                    if let Err(e) = upstream_sink.send(msg).await {
+                        error!("Failed to forward message to upstream: {}", e);
+                        break;
+                    }
+                }
+                Err(e) => {
+                    error!("Error receiving from client: {}", e);
+                    break;
+                }
+            }
+        }
+        info!("Client-to-upstream forwarding ended");
+    };
+    // Forward messages from upstream to client
+    let upstream_to_client = async {
+        while let Some(msg) = upstream_stream.next().await {
+            match msg {
+                Ok(msg) => {
+                    info!("Upstream -> Client: {:?}", msg);
+                    if let Err(e) = client_sink.send(msg).await {
+                        error!("Failed to forward message to client: {}", e);
+                        break;
+                    }
+                }
+                Err(e) => {
+                    error!("Error receiving from upstream: {}", e);
+                    break;
+                }
+            }
+        }
+        info!("Upstream-to-client forwarding ended");
+    };
+    // Run both forwarding tasks concurrently
+    tokio::select! {
+        _ = client_to_upstream => {
+            info!("Client disconnected");
+        }
+        _ = upstream_to_client => {
+            info!("Upstream disconnected");
+        }
+    }
+    info!("WebSocket forwarding session ended");
+    Ok(())
+}
+async fn handle_connection(
+    req: Request<Body>,
+    proxy: Arc<FBIProxy>,
+) -> Result<Response<Body>, Infallible> {
+    match proxy.handle_request(req).await {
+        Ok(response) => Ok(response),
+        Err(e) => {
+            error!("Request handling error: {}", e);
+            Ok(Response::builder()
+                .status(StatusCode::INTERNAL_SERVER_ERROR)
+                .body(Body::from("Internal Server Error"))
+                .unwrap())
+        }
+    }
+}
+pub async fn start_proxy_server(port: u16) -> Result<(), BoxError> {
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    let proxy = Arc::new(FBIProxy::new());
+    let make_svc = make_service_fn(move |_conn| {
+        let proxy = proxy.clone();
+        async move { Ok::<_, Infallible>(service_fn(move |req| handle_connection(req, proxy.clone()))) }
+    });
+    let server = Server::bind(&addr).serve(make_svc);
+    info!("FBI Proxy server running on http://{}", addr);
+    info!("Features: HTTP proxying + WebSocket forwarding + Port encoding");
+    if let Err(e) = server.await {
+        error!("Server error: {}", e);
+    }
+    Ok(())
+}
+fn main() {
+    env_logger::init();
+    // Read port from environment variable, default to 24306
+    let port = std::env::var("PROXY_PORT")
+        .unwrap_or_else(|_| "24306".to_string())
+        .parse::<u16>()
+        .unwrap_or_else(|_| {
+            error!("Invalid PROXY_PORT value, using default 24306");
+            24306
+        });
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    rt.block_on(async {
+        info!(
+            "Starting FBI Proxy with Hyper + proper WebSocket forwarding on port {}",
+            port
+        );
+        if let Err(e) = start_proxy_server(port).await {
+            error!("Failed to start proxy server: {}", e);
+        }
+    });
+}

package/ts/cli.ts ADDED Viewed

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+import getPort from "get-port";
+import minimist from "minimist";
+import hotMemo from "hot-memo";
+import { exec } from "child_process";
+import path from "path";
+import { exists } from "fs/promises";
+import { existsSync } from "fs";
+// 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);
+}
+const getProxyPath = () => {
+  const root = Bun.fileURLToPath(import.meta.url) + "../";
+  const filename =
+    {
+      "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";
+  return [path.join(root, "rs/target/release", filename)].find((e) =>
+    existsSync(e)
+  );
+};
+// 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
+  },
+  alias: {
+    dev: "d",
+    tls: "t",
+  },
+});
+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
+`);
+  process.exit(0);
+}
+const isDev = argv.dev || argv.d || false;
+const PROXY_PORT = String(await getPort({ port: 24306 }));
+const proxyProcess = await hotMemo(async () => {
+  console.log("Starting Rust proxy server");
+  // 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 rsTargetDir = path.join(__dirname, "../rs", "target", "release");
+    const proxyBinary = process.platform === "win32" ? "proxy.exe" : "proxy";
+    const proxyPath = path.join(rsTargetDir, proxyBinary);
+    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}`, {
+    env: {
+      ...process.env,
+      PROXY_PORT, // Rust proxy server port
+      TLS: argv.tls || "internal", // Use internal TLS by default, or set via command line argument
+    },
+    cwd: path.dirname(Caddyfile),
+  });
+  // 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");
+const exit = () => {
+  console.log("Shutting down...");
+  proxyProcess?.kill?.();
+  caddyProcess?.kill?.();
+  process.exit(0);
+};
+process.on("SIGINT", exit);
+process.on("SIGTERM", exit);
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught exception:", err);
+  exit();
+});

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}