@rubriclab/bunl 0.1.25 → 0.2.0

package/.env.example

@@ -1,3 +1,4 @@
 PORT=1234
 SCHEME=https
-DOMAIN=example.so
+DOMAIN=example.so
+HOST=localhost

package/.github/workflows/publish.yml

@@ -0,0 +1,16 @@
+name: Release Package
+
+on:
+ push:
+  branches:
+   - main
+
+permissions:
+ contents: read
+ packages: write
+ id-token: write
+
+jobs:
+ release:
+  uses: rubriclab/package/.github/workflows/release-package.yml@main
+  secrets: inherit

package/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+	"[json]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[typescript]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[typescriptreact]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"editor.codeActionsOnSave": {
+		"source.fixAll.biome": "always"
+	},
+	"editor.defaultFormatter": "biomejs.biome",
+	"editor.formatOnSave": true
+}

package/Dockerfile

@@ -1,15 +1,13 @@
-FROM oven/bun:1 as base
+FROM oven/bun:1.3-slim AS base
 
 WORKDIR /app
 
-COPY package.json /app/
-COPY bun.lockb /app/
-
+COPY package.json bun.lock ./
 RUN bun install --frozen-lockfile --production
 
-COPY . /app
+COPY . .
 
-ENV NODE_ENV production
-ENTRYPOINT ["bun", "server"]
+ENV NODE_ENV=production
+EXPOSE 1234
 
-EXPOSE 1234
+ENTRYPOINT ["bun", "run", "server.ts"]

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 Rubric Labs Inc
+Copyright (c) 2026 Rubric Labs Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/biome.json

@@ -0,0 +1,3 @@
+{
+	"extends": ["@rubriclab/config/biome"]
+}

package/build/client.js

@@ -1,508 +1,131 @@
 #! /usr/bin/env bun
 // @bun
 // client.ts
-import {parseArgs} from "util";
+import { parseArgs } from "util";
 
-// node_modules/open/index.js
-import process6 from "process";
-import {Buffer} from "buffer";
-import path from "path";
-import {fileURLToPath} from "url";
-import childProcess from "child_process";
-import fs4, {constants as fsConstants} from "fs/promises";
-
-// node_modules/is-wsl/index.js
-import process2 from "process";
-import os from "os";
-import fs3 from "fs";
-
-// node_modules/is-inside-container/index.js
-import fs2 from "fs";
-
-// node_modules/is-docker/index.js
-import fs from "fs";
-function hasDockerEnv() {
-  try {
-    fs.statSync("/.dockerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasDockerCGroup() {
-  try {
-    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
-  } catch {
-    return false;
-  }
-}
-var isDockerCached;
-function isDocker() {
-  if (isDockerCached === undefined) {
-    isDockerCached = hasDockerEnv() || hasDockerCGroup();
-  }
-  return isDockerCached;
-}
-
-// node_modules/is-inside-container/index.js
-var cachedResult;
-var hasContainerEnv = () => {
-  try {
-    fs2.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-};
-function isInsideContainer() {
-  if (cachedResult === undefined) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-
-// node_modules/is-wsl/index.js
-var isWsl = () => {
-  if (process2.platform !== "linux") {
-    return false;
-  }
-  if (os.release().toLowerCase().includes("microsoft")) {
-    if (isInsideContainer()) {
-      return false;
-    }
-    return true;
-  }
-  try {
-    return fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
-  } catch {
-    return false;
-  }
-};
-var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-
-// node_modules/define-lazy-prop/index.js
-function defineLazyProperty(object, propertyName, valueGetter) {
-  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
-  Object.defineProperty(object, propertyName, {
-    configurable: true,
-    enumerable: true,
-    get() {
-      const result = valueGetter();
-      define(result);
-      return result;
-    },
-    set(value) {
-      define(value);
-    }
-  });
-  return object;
-}
-
-// node_modules/default-browser/index.js
-import {promisify as promisify4} from "util";
-import process5 from "process";
-import {execFile as execFile4} from "child_process";
-
-// node_modules/default-browser-id/index.js
-import {promisify} from "util";
-import process3 from "process";
-import {execFile} from "child_process";
-var execFileAsync = promisify(execFile);
-async function defaultBrowserId() {
-  if (process3.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
-  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
-  return match?.groups.id ?? "com.apple.Safari";
-}
-
-// node_modules/run-applescript/index.js
-import process4 from "process";
-import {promisify as promisify2} from "util";
-import {execFile as execFile2, execFileSync} from "child_process";
-async function runAppleScript(script, { humanReadableOutput = true } = {}) {
-  if (process4.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const outputArguments = humanReadableOutput ? [] : ["-ss"];
-  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments]);
-  return stdout.trim();
-}
-var execFileAsync2 = promisify2(execFile2);
-
-// node_modules/bundle-name/index.js
-async function bundleName(bundleId) {
-  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
-tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
-}
-
-// node_modules/default-browser/windows.js
-import {promisify as promisify3} from "util";
-import {execFile as execFile3} from "child_process";
-var execFileAsync3 = promisify3(execFile3);
-var windowsBrowserProgIds = {
-  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
-  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
-  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
-  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
-  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
-  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
-  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
-  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
-  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
-};
-
-class UnknownBrowserError extends Error {
-}
-async function defaultBrowser(_execFileAsync = execFileAsync3) {
-  const { stdout } = await _execFileAsync("reg", [
-    "QUERY",
-    " HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice",
-    "/v",
-    "ProgId"
-  ]);
-  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
-  if (!match) {
-    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
-  }
-  const { id } = match.groups;
-  const browser = windowsBrowserProgIds[id];
-  if (!browser) {
-    throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
-  }
-  return browser;
-}
-
-// node_modules/default-browser/index.js
-var execFileAsync4 = promisify4(execFile4);
-var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-async function defaultBrowser2() {
-  if (process5.platform === "darwin") {
-    const id = await defaultBrowserId();
-    const name = await bundleName(id);
-    return { name, id };
-  }
-  if (process5.platform === "linux") {
-    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
-    const id = stdout.trim();
-    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
-    return { name, id };
-  }
-  if (process5.platform === "win32") {
-    return defaultBrowser();
-  }
-  throw new Error("Only macOS, Linux, and Windows are supported");
+// utils.ts
+function openBrowser(url) {
+  const cmds = {
+    darwin: ["open", url],
+    win32: ["cmd", "/c", "start", url]
+  };
+  const args = cmds[process.platform] ?? ["xdg-open", url];
+  Bun.spawn(args, { stdio: ["ignore", "ignore", "ignore"] });
 }
-
-// node_modules/open/index.js
-function detectArchBinary(binary) {
-  if (typeof binary === "string" || Array.isArray(binary)) {
-    return binary;
-  }
-  const { [arch]: archBinary } = binary;
-  if (!archBinary) {
-    throw new Error(`${arch} is not supported`);
-  }
-  return archBinary;
+function toBase64(buf) {
+  return Buffer.from(buf).toString("base64");
 }
-function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
-  if (wsl && is_wsl_default) {
-    return detectArchBinary(wsl);
-  }
-  if (!platformBinary) {
-    throw new Error(`${platform} is not supported`);
-  }
-  return detectArchBinary(platformBinary);
+function fromBase64(str) {
+  const buf = Buffer.from(str, "base64");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
 }
-var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
-var localXdgOpenPath = path.join(__dirname2, "xdg-open");
-var { platform, arch } = process6;
-var getWslDrivesMountPoint = (() => {
-  const defaultMountPoint = "/mnt/";
-  let mountPoint;
-  return async function() {
-    if (mountPoint) {
-      return mountPoint;
-    }
-    const configFilePath = "/etc/wsl.conf";
-    let isConfigFileExists = false;
-    try {
-      await fs4.access(configFilePath, fsConstants.F_OK);
-      isConfigFileExists = true;
-    } catch {
-    }
-    if (!isConfigFileExists) {
-      return defaultMountPoint;
-    }
-    const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
-    const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
-    if (!configMountPoint) {
-      return defaultMountPoint;
-    }
-    mountPoint = configMountPoint.groups.mountPoint.trim();
-    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
-    return mountPoint;
-  };
-})();
-var pTryEach = async (array, mapper) => {
-  let latestError;
-  for (const item of array) {
-    try {
-      return await mapper(item);
-    } catch (error) {
-      latestError = error;
-    }
-  }
-  throw latestError;
-};
-var baseOpen = async (options) => {
-  options = {
-    wait: false,
-    background: false,
-    newInstance: false,
-    allowNonzeroExitCode: false,
-    ...options
-  };
-  if (Array.isArray(options.app)) {
-    return pTryEach(options.app, (singleApp) => baseOpen({
-      ...options,
-      app: singleApp
-    }));
-  }
-  let { name: app, arguments: appArguments = [] } = options.app ?? {};
-  appArguments = [...appArguments];
-  if (Array.isArray(app)) {
-    return pTryEach(app, (appName) => baseOpen({
-      ...options,
-      app: {
-        name: appName,
-        arguments: appArguments
-      }
-    }));
-  }
-  if (app === "browser" || app === "browserPrivate") {
-    const ids = {
-      "com.google.chrome": "chrome",
-      "google-chrome.desktop": "chrome",
-      "org.mozilla.firefox": "firefox",
-      "firefox.desktop": "firefox",
-      "com.microsoft.msedge": "edge",
-      "com.microsoft.edge": "edge",
-      "microsoft-edge.desktop": "edge"
-    };
-    const flags = {
-      chrome: "--incognito",
-      firefox: "--private-window",
-      edge: "--inPrivate"
-    };
-    const browser = await defaultBrowser2();
-    if (browser.id in ids) {
-      const browserName = ids[browser.id];
-      if (app === "browserPrivate") {
-        appArguments.push(flags[browserName]);
-      }
-      return baseOpen({
-        ...options,
-        app: {
-          name: apps[browserName],
-          arguments: appArguments
-        }
-      });
-    }
-    throw new Error(`${browser.name} is not supported as a default browser`);
-  }
-  let command;
-  const cliArguments = [];
-  const childProcessOptions = {};
-  if (platform === "darwin") {
-    command = "open";
-    if (options.wait) {
-      cliArguments.push("--wait-apps");
-    }
-    if (options.background) {
-      cliArguments.push("--background");
-    }
-    if (options.newInstance) {
-      cliArguments.push("--new");
-    }
-    if (app) {
-      cliArguments.push("-a", app);
-    }
-  } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
-    const mountPoint = await getWslDrivesMountPoint();
-    command = is_wsl_default ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process6.env.SYSTEMROOT || process6.env.windir || "C:\Windows"}\System32\WindowsPowerShell\v1.0\powershell`;
-    cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
-    if (!is_wsl_default) {
-      childProcessOptions.windowsVerbatimArguments = true;
-    }
-    const encodedArguments = ["Start"];
-    if (options.wait) {
-      encodedArguments.push("-Wait");
-    }
-    if (app) {
-      encodedArguments.push(`"\`"${app}\`""`);
-      if (options.target) {
-        appArguments.push(options.target);
-      }
-    } else if (options.target) {
-      encodedArguments.push(`"${options.target}"`);
-    }
-    if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
-      encodedArguments.push("-ArgumentList", appArguments.join(","));
-    }
-    options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
-  } else {
-    if (app) {
-      command = app;
-    } else {
-      const isBundled = !__dirname2 || __dirname2 === "/";
-      let exeLocalXdgOpen = false;
-      try {
-        await fs4.access(localXdgOpenPath, fsConstants.X_OK);
-        exeLocalXdgOpen = true;
-      } catch {
-      }
-      const useSystemXdgOpen = process6.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
-      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
-    }
-    if (appArguments.length > 0) {
-      cliArguments.push(...appArguments);
-    }
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-      childProcessOptions.detached = true;
-    }
-  }
-  if (platform === "darwin" && appArguments.length > 0) {
-    cliArguments.push("--args", ...appArguments);
-  }
-  if (options.target) {
-    cliArguments.push(options.target);
-  }
-  const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
-  if (options.wait) {
-    return new Promise((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode > 0) {
-          reject(new Error(`Exited with code ${exitCode}`));
-          return;
-        }
-        resolve(subprocess);
-      });
-    });
-  }
-  subprocess.unref();
-  return subprocess;
-};
-var open = (target, options) => {
-  if (typeof target !== "string") {
-    throw new TypeError("Expected a `target`");
-  }
-  return baseOpen({
-    ...options,
-    target
-  });
-};
-var apps = {};
-defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
-  darwin: "google chrome",
-  win32: "chrome",
-  linux: ["google-chrome", "google-chrome-stable", "chromium"]
-}, {
-  wsl: {
-    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
-    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
-  }
-}));
-defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
-  darwin: "firefox",
-  win32: "C:\Program Files\Mozilla Firefox\firefox.exe",
-  linux: "firefox"
-}, {
-  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
-}));
-defineLazyProperty(apps, "edge", () => detectPlatformBinary({
-  darwin: "microsoft edge",
-  win32: "msedge",
-  linux: ["microsoft-edge", "microsoft-edge-dev"]
-}, {
-  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
-}));
-defineLazyProperty(apps, "browser", () => "browser");
-defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
-var open_default = open;
 
 // client.ts
 async function main({
   port,
   domain,
   subdomain,
-  open: open2
+  open
 }) {
   const params = new URLSearchParams({
     new: "",
     ...subdomain ? { subdomain } : {}
   }).toString();
-  const serverUrl = `ws://${domain}?${params}`;
+  const isLocal = /^(localhost|127\.|0\.0\.0\.0|\[::1\])/.test(domain || "");
+  const wsScheme = isLocal ? "ws" : "wss";
+  const serverUrl = `${wsScheme}://${domain}?${params}`;
   const socket = new WebSocket(serverUrl);
-  const url = `http://localhost:${port}`;
+  const localHost = Bun.env.HOST || "localhost";
+  const localOrigin = `http://${localHost}:${port}`;
   socket.addEventListener("message", async (event) => {
     const data = JSON.parse(event.data);
-    if (data.url) {
+    if (data.type === "init") {
+      const init = data;
       console.log(`
-\u21AA Your URL: ${data.url}
+\u21AA Your URL: \x1B[32m${init.url}\x1B[0m
 `);
-      if (open2)
-        open_default(data.url);
+      if (open)
+        openBrowser(init.url);
+      return;
     }
-    const { method, headers: reqHeaders, pathname, body: reqBody } = data;
-    if (method) {
+    if (data.type === "request") {
+      const req = data;
       const now = performance.now();
-      const res = await fetch(`${url}${pathname || ""}`, {
-        method,
-        headers: reqHeaders,
-        body: reqBody
-      });
-      const elapsed = performance.now() - now;
-      console.log(`${method} ${pathname} in ${elapsed.toFixed(2)}ms`);
-      const { status, statusText, headers } = res;
-      const body = await res.text();
-      const payload = {
-        method,
-        pathname,
-        status,
-        statusText,
-        headers,
-        body
-      };
-      socket.send(JSON.stringify(payload));
+      try {
+        const reqBody = req.body && req.method !== "GET" && req.method !== "HEAD" ? fromBase64(req.body) : null;
+        const fwdHeaders = { ...req.headers };
+        delete fwdHeaders.host;
+        delete fwdHeaders.connection;
+        delete fwdHeaders["transfer-encoding"];
+        const res = await fetch(`${localOrigin}${req.pathname}`, {
+          body: reqBody,
+          headers: fwdHeaders,
+          method: req.method
+        });
+        const elapsed = (performance.now() - now).toFixed(1);
+        console.log(`\x1B[32m${req.method}\x1B[0m ${req.pathname} \u2192 ${res.status} (${elapsed}ms)`);
+        const resBody = await res.arrayBuffer();
+        const headers = {};
+        res.headers.forEach((v, k) => {
+          headers[k] = v;
+        });
+        const response = {
+          body: toBase64(resBody),
+          headers,
+          id: req.id,
+          status: res.status,
+          statusText: res.statusText,
+          type: "response"
+        };
+        socket.send(JSON.stringify(response));
+      } catch (err) {
+        console.error(`\x1B[31mERR\x1B[0m ${req.method} ${req.pathname}: ${err}`);
+        const response = {
+          body: toBase64(new TextEncoder().encode(`Failed to reach localhost:${port} \u2014 ${err}`).buffer),
+          headers: { "content-type": "text/plain" },
+          id: req.id,
+          status: 502,
+          statusText: "Bad Gateway",
+          type: "response"
+        };
+        socket.send(JSON.stringify(response));
+      }
     }
   });
-  socket.addEventListener("open", (event) => {
-    if (!event.target.readyState)
-      throw "not ready";
+  socket.addEventListener("open", () => {
+    console.log(`Connected to ${serverUrl}`);
   });
   socket.addEventListener("close", () => {
-    console.warn("server closed connection");
-    process.exit();
+    console.warn("Server closed connection");
+    process.exit(1);
+  });
+  socket.addEventListener("error", (err) => {
+    console.error("WebSocket error:", err);
+    process.exit(1);
   });
 }
 var { values } = parseArgs({
+  allowPositionals: true,
   args: process.argv,
   options: {
-    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
+    domain: { default: "localhost:1234", short: "d", type: "string" },
+    open: { short: "o", type: "boolean" },
+    port: { default: "3000", short: "p", type: "string" },
+    subdomain: { short: "s", type: "string" },
+    version: { short: "v", type: "boolean" }
+  }
 });
 if (values.version) {
-  console.log("0.1.25");
+  const pkg = await Bun.file(new URL("./package.json", import.meta.url)).json();
+  console.log(pkg.version);
   process.exit();
 }
-main(values);
+main({
+  domain: values.domain || "localhost:1234",
+  open: values.open || false,
+  port: values.port || "3000",
+  subdomain: values.subdomain || ""
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});