@rubriclab/bunl 0.0.23 → 0.1.24

package/build/client.js

@@ -437,7 +437,7 @@ var open_default = open;
 
 // client.ts
 async function main({
-  url,
+  port,
   domain,
   subdomain,
   open: open2
@@ -448,6 +448,7 @@ async function main({
   }).toString();
   const serverUrl = `ws://${domain}?${params}`;
   const socket = new WebSocket(serverUrl);
+  const url = `http://localhost:${port}`;
   socket.addEventListener("message", async (event) => {
     const data = JSON.parse(event.data);
     if (data.url) {
@@ -458,6 +459,7 @@ async function main({
         open_default(data.url);
     }
     if (data.method) {
+      console.log(`${data.method} ${data.pathname}`);
       const res = await fetch(`${url}${data.pathname || ""}`, {
         method: data.method,
         headers: data.headers,
@@ -465,63 +467,39 @@ async function main({
       });
       const { status, statusText, headers } = res;
       const body = await res.text();
-      const serializedRes = JSON.stringify({
+      const payload = {
+        method: data.method,
         pathname: data.pathname,
         status,
         statusText,
         headers: Object.fromEntries(headers),
         body
-      });
-      socket.send(serializedRes);
+      };
+      socket.send(JSON.stringify(payload));
     }
   });
   socket.addEventListener("open", (event) => {
     if (!event.target.readyState)
-      throw "Not ready";
+      throw "not ready";
   });
   socket.addEventListener("close", () => {
-    console.log(`failed to connect to server`);
+    console.warn("server closed connection");
     process.exit();
   });
 }
 var { values } = parseArgs({
   args: process.argv,
   options: {
-    port: {
-      type: "string",
-      required: true,
-      short: "p"
-    },
-    domain: {
-      type: "string",
-      default: "localhost:1234",
-      short: "d"
-    },
-    subdomain: {
-      type: "string",
-      short: "s"
-    },
-    open: {
-      type: "boolean",
-      short: "o"
-    },
-    version: {
-      type: "boolean",
-      short: "v"
-    }
+    port: { type: "string", short: "p", default: "3000" },
+    domain: { type: "string", short: "d", default: "localhost:1234" },
+    subdomain: { type: "string", short: "s" },
+    open: { type: "boolean", short: "o" },
+    version: { type: "boolean", short: "v" }
   },
   allowPositionals: true
 });
 if (values.version) {
-  console.log("0.0.23");
+  console.log("0.1.24");
   process.exit();
 }
-if (!values.port)
-  throw "pass -p 3000";
-var { port, domain, subdomain, open: open2 } = values;
-main({
-  url: `localhost:${port}`,
-  domain,
-  subdomain,
-  open: open2
-});
+main(values);

package/client.ts

@@ -1,13 +1,14 @@
 import { parseArgs } from "util";
 import browser from "open";
+import type { Payload } from "./types";
 
 async function main({
-  url,
+  port,
   domain,
   subdomain,
   open,
 }: {
-  url: string;
+  port?: string;
   domain?: string;
   subdomain?: string;
   open?: boolean;
@@ -19,6 +20,8 @@ async function main({
   const serverUrl = `ws://${domain}?${params}`;
   const socket = new WebSocket(serverUrl);
 
+  const url = `http://localhost:${port}`;
+
   socket.addEventListener("message", async (event) => {
     const data = JSON.parse(event.data as string);
 
@@ -28,6 +31,8 @@ async function main({
     }
 
     if (data.method) {
+      console.log(`\x1b[32m${data.method}\x1b[0m ${data.pathname}`);
+
       const res = await fetch(`${url}${data.pathname || ""}`, {
         method: data.method,
         headers: data.headers,
@@ -37,24 +42,25 @@ async function main({
       const { status, statusText, headers } = res;
       const body = await res.text();
 
-      const serializedRes = JSON.stringify({
+      const payload: Payload = {
+        method: data.method,
         pathname: data.pathname,
         status,
         statusText,
         headers: Object.fromEntries(headers),
         body,
-      });
+      };
 
-      socket.send(serializedRes);
+      socket.send(JSON.stringify(payload));
     }
   });
 
   socket.addEventListener("open", (event) => {
-    if (!event.target.readyState) throw "Not ready";
+    if (!event.target.readyState) throw "not ready";
   });
 
   socket.addEventListener("close", () => {
-    console.log(`\x1b[31mfailed to connect to server\x1b[0m`);
+    console.warn("server closed connection");
     process.exit();
   });
 }
@@ -67,28 +73,11 @@ async function main({
 const { values } = parseArgs({
   args: process.argv,
   options: {
-    port: {
-      type: "string",
-      required: true,
-      short: "p",
-    },
-    domain: {
-      type: "string",
-      default: "localhost:1234",
-      short: "d",
-    },
-    subdomain: {
-      type: "string",
-      short: "s",
-    },
-    open: {
-      type: "boolean",
-      short: "o",
-    },
-    version: {
-      type: "boolean",
-      short: "v",
-    },
+    port: { type: "string", short: "p", default: "3000" },
+    domain: { type: "string", short: "d", default: "localhost:1234" },
+    subdomain: { type: "string", short: "s" },
+    open: { type: "boolean", short: "o" },
+    version: { type: "boolean", short: "v" },
   },
   allowPositionals: true,
 });
@@ -98,13 +87,4 @@ if (values.version) {
   process.exit();
 }
 
-if (!values.port) throw "pass -p 3000";
-
-const { port, domain, subdomain, open } = values;
-
-main({
-  url: `localhost:${port}`,
-  domain,
-  subdomain,
-  open,
-});
+main(values);

package/package.json

@@ -4,7 +4,7 @@
   },
   "name": "@rubriclab/bunl",
   "description": "Expose localhost to the world",
-  "version": "0.0.23",
+  "version": "0.1.24",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,9 +20,9 @@
   "main": "build/client.js",
   "scripts": {
     "server": "bun server.ts",
-    "dev:server": "bun --hot server.ts",
-    "client": "bun --hot client.ts",
-    "demo": "bun --hot demo.ts",
+    "dev:server": "bun --watch server.ts",
+    "client": "bun --watch client.ts",
+    "demo": "bun --watch demo.ts",
     "client:upgrade": "bun rm -g @rubriclab/bunl && bun i -g @rubriclab/bunl@latest",
     "build": "BUILD=build/client.js && bun build client.ts --outdir build --target bun && echo -e \"#! /usr/bin/env bun\n$(cat $BUILD)\" > $BUILD",
     "npm:publish": "bun run build && npm publish"

package/server.ts

@@ -1,14 +1,13 @@
-import { serve, sleep, type ServerWebSocket } from "bun";
+import { serve, type ServerWebSocket } from "bun";
 import { uid } from "./utils";
-
-type Client = { id: string };
+import type { Client, Payload } from "./types";
 
 const port = Bun.env.PORT || 1234;
 const scheme = Bun.env.SCHEME || "http";
 const domain = Bun.env.DOMAIN || `localhost:${port}`;
 
 const clients = new Map<string, ServerWebSocket<Client>>();
-const clientData = new Map<string, string>();
+const requesters = new Map<string, WritableStream>();
 
 serve<Client>({
   port,
@@ -28,65 +27,57 @@ serve<Client>({
     const subdomain = reqUrl.hostname.split(".")[0];
 
     if (!clients.has(subdomain)) {
-      return new Response("client not found", { status: 404 });
+      return new Response(`${subdomain} not found`, { status: 404 });
     }
 
     // The magic: forward the req to the client
     const client = clients.get(subdomain)!;
     const { method, url, headers: reqHeaders } = req;
     const reqBody = await req.text();
-    const pathname = new URL(url).pathname || "";
-    client.send(
-      JSON.stringify({ method, pathname, body: reqBody, headers: reqHeaders })
-    );
-
-    // Wait for the client to cache its response above
-    await sleep(1);
+    const pathname = new URL(url).pathname;
+    const payload: Payload = {
+      method,
+      pathname,
+      body: reqBody,
+      headers: reqHeaders,
+    };
 
-    let retries = 5;
-    let res = clientData.get(`${subdomain}/${pathname}`);
+    const { writable, readable } = new TransformStream();
 
-    // Poll every second for the client to respond
-    // TODO: replace poll with a client-triggered callback
-    while (!res) {
-      await sleep(1000);
-      retries--;
+    requesters.set(`${method}:${subdomain}${pathname}`, writable);
+    client.send(JSON.stringify(payload));
 
-      res = clientData.get(`${subdomain}/${pathname}`);
-
-      if (retries < 1) {
-        return new Response("client not responding", { status: 500 });
-      }
-    }
-
-    const { status, statusText, headers, body } = JSON.parse(res);
-    delete headers["content-encoding"];
+    const res = await readable.getReader().read();
+    const { status, statusText, headers, body } = JSON.parse(res.value);
 
     return new Response(body, { status, statusText, headers });
   },
   websocket: {
     open(ws) {
       clients.set(ws.data.id, ws);
-      console.log(
-        `\x1b[32mconnected to ${ws.data.id} (${clients.size} total)\x1b[0m`
-      );
+      console.log(`\x1b[32m+ ${ws.data.id} (${clients.size} total)\x1b[0m`);
       ws.send(
         JSON.stringify({
           url: `${scheme}://${ws.data.id}.${domain}`,
         })
       );
     },
-    message(ws, message: string) {
-      console.log("message from", ws.data.id);
+    message: async ({ data: { id } }, message: string) => {
+      console.log("message from", id);
+
+      const { method, pathname } = JSON.parse(message) as Payload;
+      const writable = requesters.get(`${method}:${id}${pathname}`);
+      if (!writable) throw "connection not found";
 
-      const { pathname } = JSON.parse(message);
-      clientData.set(`${ws.data.id}/${pathname}`, message);
+      const writer = writable.getWriter();
+      await writer.write(message);
+      await writer.close();
     },
-    close(ws) {
-      console.log("closing", ws.data.id);
-      clients.delete(ws.data.id);
+    close({ data }) {
+      console.log("closing", data.id);
+      clients.delete(data.id);
     },
   },
 });
 
-console.log(`Websocket server up at ws://${domain}`);
+console.log(`websocket server up at ws://${domain}`);

package/types.ts

@@ -0,0 +1,10 @@
+export type Client = { id: string };
+
+export type Payload = {
+  status?: number;
+  statusText?: string;
+  method?: string;
+  pathname?: string;
+  body: string;
+  headers: object;
+};