@rubriclab/bunl 0.0.0

package/.dockerignore

@@ -0,0 +1,2 @@
+.git
+node_modules

package/Dockerfile

@@ -0,0 +1,15 @@
+FROM oven/bun:1 as base
+
+WORKDIR /app
+
+COPY package.json /app/
+COPY bun.lockb /app/
+
+RUN bun install --frozen-lockfile --production
+
+COPY . /app
+
+ENV NODE_ENV production
+ENTRYPOINT ["bun", "server"]
+
+EXPOSE 1234

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Roman Shtylman
+
+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/README.md

@@ -0,0 +1,27 @@
+# bunl
+
+## A Bun WebSocket re-write of LocalTunnel
+
+To install dependencies:
+
+```bash
+bun i
+```
+
+To run the client:
+
+```bash
+bun lt
+```
+
+To run the server:
+
+```bash
+bun server
+```
+
+To run a dummy server on localhost:3000:
+
+```bash
+bun demo
+```

package/build/client.js

@@ -0,0 +1,53 @@
+// @bun
+// client.ts
+import {parseArgs} from "util";
+async function main({
+  url,
+  domain,
+  subdomain
+}) {
+  const serverUrl = `ws://${domain || "localhost:1234"}?new${subdomain ? `&subdomain=${subdomain}` : ""}`;
+  const socket = new WebSocket(serverUrl);
+  socket.addEventListener("message", (event) => {
+    const data = JSON.parse(event.data);
+    console.log("message:", data);
+    if (data.method) {
+      fetch(`${domain}${data.path}`, {
+        method: data.method,
+        headers: data.headers
+      }).then((res) => res.text()).then((res) => {
+        socket.send(res);
+      });
+    }
+  });
+  socket.addEventListener("open", (event) => {
+    console.log("socket ready:", !!event.target.readyState);
+    socket.ping();
+  });
+}
+var { values } = parseArgs({
+  args: Bun.argv,
+  options: {
+    port: {
+      type: "string",
+      required: true,
+      short: "p"
+    },
+    domain: {
+      type: "string",
+      short: "d"
+    },
+    subdomain: {
+      type: "string",
+      short: "s"
+    }
+  },
+  allowPositionals: true
+});
+if (!values.port)
+  throw "pass --port 3000";
+main({
+  url: `localhost:${values.port}`,
+  domain: values.domain,
+  subdomain: values.subdomain
+});

package/client.ts

@@ -0,0 +1,69 @@
+import { parseArgs } from "util";
+
+async function main({
+  url,
+  domain,
+  subdomain,
+}: {
+  url: string;
+  domain?: string;
+  subdomain?: string;
+}) {
+  const serverUrl = `ws://${domain || "localhost:1234"}?new${
+    subdomain ? `&subdomain=${subdomain}` : ""
+  }`;
+  const socket = new WebSocket(serverUrl);
+
+  socket.addEventListener("message", (event) => {
+    const data = JSON.parse(event.data as string);
+    console.log("message:", data);
+
+    if (data.method) {
+      fetch(`${domain}${data.path}`, {
+        method: data.method,
+        headers: data.headers,
+      })
+        .then((res) => res.text())
+        .then((res) => {
+          socket.send(res);
+        });
+    }
+  });
+
+  socket.addEventListener("open", (event) => {
+    console.log("socket ready:", !!(event.target as any).readyState);
+    socket.ping();
+  });
+}
+
+/**
+ * Eg. `bun client.ts -p 3000 -d tunnel.example.so -s my-subdomain`
+ * > my-subdomain.tunnel.example.so will be proxied to localhost:3000
+ */
+const { values } = parseArgs({
+  args: Bun.argv,
+  options: {
+    port: {
+      type: "string",
+      required: true,
+      short: "p",
+    },
+    domain: {
+      type: "string",
+      short: "d",
+    },
+    subdomain: {
+      type: "string",
+      short: "s",
+    },
+  },
+  allowPositionals: true,
+});
+
+if (!values.port) throw "pass --port 3000";
+
+main({
+  url: `localhost:${values.port}`,
+  domain: values.domain,
+  subdomain: values.subdomain,
+});

package/demo.ts

@@ -0,0 +1,18 @@
+import { serve } from "bun";
+
+const port = 3000;
+
+serve({
+  port,
+  fetch: async (req) => {
+    const url = new URL(req.url);
+    console.log(req.method, url.pathname, url.search);
+
+    const bod = await req.text();
+    bod && console.log("Body: ", bod);
+
+    return new Response(`hello from localhost:${port}`);
+  },
+});
+
+console.log(`Serving app at http://localhost:${port}`);

package/fly.toml

@@ -0,0 +1,19 @@
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+
+app = 'tunnel'
+primary_region = 'yul'
+
+[build]
+
+[http_service]
+  internal_port = 1234
+  force_https = false
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ['app']
+
+[[vm]]
+  memory = '1gb'
+  cpu_kind = 'shared'
+  cpus = 1

package/index.ts

@@ -0,0 +1,67 @@
+import "localenv";
+import optimist from "optimist";
+import Debug from "debug";
+import { CreateServer } from "./server";
+import { type AddressInfo } from "ws";
+
+const debug = Debug("localtunnel");
+
+const argv = optimist
+  .usage("Usage: $0 --port [num]")
+  .options("secure", {
+    default: false,
+    describe: "use this flag to indicate proxy over https",
+  })
+  .options("port", {
+    default: "80",
+    describe: "listen on this port for outside requests",
+  })
+  .options("address", {
+    default: "0.0.0.0",
+    describe: "IP address to bind to",
+  })
+  .options("domain", {
+    describe:
+      "Specify the base domain name. This is optional if hosting localtunnel from a regular example.com domain. This is required if hosting a localtunnel server from a subdomain (i.e. lt.example.dom where clients will be client-app.lt.example.come)",
+  })
+  .options("max-sockets", {
+    default: 10,
+    describe:
+      "maximum number of tcp sockets each client is allowed to establish at one time (the tunnels)",
+  }).argv;
+
+if (argv.help) {
+  console.log("Showing help");
+  optimist.showHelp();
+  process.exit();
+}
+
+const server = CreateServer({
+  max_tcp_sockets: argv["max-sockets"],
+  secure: argv.secure,
+  domain: argv.domain,
+});
+
+server.listen(argv.port, argv.address, () => {
+  debug("server listening on port: %d", (server.address() as AddressInfo).port);
+});
+
+process.on("SIGINT", () => {
+  console.error("SIGINT");
+  process.exit();
+});
+
+process.on("SIGTERM", () => {
+  console.warn("SIGTERM");
+  // process.exit();
+});
+
+process.on("uncaughtException", (err) => {
+  console.error("err:");
+  console.error(err);
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("reason:");
+  console.error(reason);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "bin": {
+    "bunl": "./client.js"
+  },
+  "name": "@rubriclab/bunl",
+  "description": "expose localhost to the world",
+  "version": "0.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RubricLab/bunl.git"
+  },
+  "dependencies": {
+    "human-id": "^4.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "scripts": {
+    "server": "bun --hot server.ts",
+    "lt": "bun --hot client.ts",
+    "demo": "bun --hot demo.ts"
+  },
+  "type": "module",
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "@RubricLab:registry": "https://registry.npmjs.org",
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "homepage": "https://github.com/RubricLab/bunl#readme",
+  "keywords": [
+    "local",
+    "tunnel",
+    "rubric"
+  ]
+}

package/server.ts

@@ -0,0 +1,82 @@
+import { serve, sleep, type ServerWebSocket } from "bun";
+import { uid } from "./utils";
+
+type Client = { id: string };
+
+const port = Bun.env.PORT || 1234;
+const protocol = "http";
+const domain = Bun.env.DOMAIN || `localhost:${port}`;
+
+const clients = new Map<string, ServerWebSocket<Client>>();
+const clientData = new Map<string, any>();
+
+serve<Client>({
+  port,
+  fetch: async (req, server) => {
+    const reqUrl = new URL(req.url);
+
+    if (reqUrl.searchParams.has("new")) {
+      const id = reqUrl.searchParams.get("subdomain") || uid();
+      const upgraded = server.upgrade(req, { data: { id } });
+      if (upgraded) return;
+      else return new Response("Upgrade failed :(", { status: 500 });
+    }
+
+    const subdomain = reqUrl.hostname.split(".")[0];
+
+    if (!clients.has(subdomain)) {
+      console.log(`\x1b[31m${subdomain} not found \x1b[0m`);
+      return new Response("client not found :(", { status: 404 });
+    }
+
+    // The magic: forward the req to the client
+    const client = clients.get(subdomain)!;
+    const { method, url, headers } = req;
+    const path = new URL(url).pathname;
+    client.send(JSON.stringify({ method, path, headers }));
+
+    // Wait for the client to cache its response above
+    await sleep(1);
+
+    let retries = 5;
+    let res = clientData.get(subdomain);
+
+    // Poll every second for the client to respond
+    // TODO: replace this with a way for the client to trigger this
+    while (!res) {
+      await sleep(1000);
+      retries--;
+
+      res = clientData.get(subdomain);
+
+      if (retries < 1) {
+        console.log(`\x1b[31m${subdomain} not responding \x1b[0m`);
+        return new Response("client not responding :(", { status: 500 });
+      }
+    }
+
+    return new Response(res);
+  },
+  websocket: {
+    open(ws) {
+      console.log("connecting to", ws.data.id);
+      clients.set(ws.data.id, ws);
+      ws.send(
+        JSON.stringify({
+          id: ws.data.id,
+          url: `${protocol}://${ws.data.id}.${domain}`,
+        })
+      );
+    },
+    message(ws, message) {
+      console.log("message from", ws.data.id);
+      clientData.set(ws.data.id, message);
+    },
+    close(ws) {
+      console.log(`closing ${ws.data.id}`);
+      clients.delete(ws.data.id);
+    },
+  },
+});
+
+console.log(`Websocket server up at ws://${domain}`);

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["esnext"],
+    "target": "esnext",
+    "module": "esnext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun-types"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "declaration": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/utils.ts

@@ -0,0 +1,6 @@
+import { humanId } from "human-id";
+/**
+ * Generate a human-readable unique identifier
+ * Eg. all-zebras-eat
+ */
+export const uid = () => humanId({ capitalize: false, separator: "-" });