@rubriclab/bunl 0.0.13 → 0.0.15

package/.env.example

@@ -0,0 +1,3 @@
+PORT=1234
+SCHEME=https
+DOMAIN=example.so

package/README.md

@@ -21,7 +21,7 @@ bun i
 To run the server:
 
 ```bash
-bun server
+bun dev:server
 ```
 
 (Optional) to run a dummy process on localhost:3000:

package/build/client.js

@@ -1,25 +1,487 @@
 #! /usr/bin/env bun
 // client.ts
-import { parseArgs } from "util";
-async function main({ url, domain, subdomain }) {
-  const serverUrl = `ws://${domain || "localhost:1234"}?new${
-    subdomain ? `&subdomain=${subdomain}` : ""
-  }`;
+import {parseArgs} from "util";
+
+// node_modules/open/index.js
+import process6 from "node:process";
+import {Buffer} from "node:buffer";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import childProcess from "node:child_process";
+import fs4, {constants as fsConstants} from "node:fs/promises";
+
+// node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+
+// node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+
+// node_modules/is-docker/index.js
+import fs from "node:fs";
+var hasDockerEnv = function() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hasDockerCGroup = function() {
+  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 "node:util";
+import process5 from "node:process";
+import {execFile as execFile4} from "node:child_process";
+
+// node_modules/default-browser-id/index.js
+import {promisify} from "node:util";
+import process3 from "node:process";
+import {execFile} from "node: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 "node:process";
+import {promisify as promisify2} from "node:util";
+import {execFile as execFile2, execFileSync} from "node: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 "node:util";
+import {execFile as execFile3} from "node: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");
+}
+
+// node_modules/open/index.js
+var detectArchBinary = function(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;
+};
+var detectPlatformBinary = function({ [platform]: platformBinary }, { wsl }) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+};
+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({
+  url,
+  domain,
+  subdomain,
+  open: open2
+}) {
+  const params = new URLSearchParams({
+    new: "",
+    ...subdomain ? { subdomain } : {}
+  }).toString();
+  const serverUrl = `ws://${domain}?${params}`;
   const socket = new WebSocket(serverUrl);
-  socket.addEventListener("message", (event) => {
+  socket.addEventListener("message", async (event) => {
     const data = JSON.parse(event.data);
-    console.log("message:", data);
+    if (data.url) {
+      console.log(`
+
+\u21AA Your URL: ${data.url}
+`);
+      if (open2)
+        open_default(data.url);
+    }
     if (data.method) {
-      fetch(`${url}${data.path}`, {
+      const res = await fetch(`${url}${data.pathname}`, {
         method: data.method,
         headers: data.headers,
-      })
-        .then((res) => res.text())
-        .then((res) => socket.send(res));
+        body: data.body
+      });
+      const { status, statusText, headers } = res;
+      const body = await res.text();
+      const serializedRes = JSON.stringify({
+        pathname: data.pathname,
+        status,
+        statusText,
+        headers: Object.fromEntries(headers),
+        body
+      });
+      socket.send(serializedRes);
     }
   });
   socket.addEventListener("open", (event) => {
-    if (!event.target.readyState) throw "Not ready";
+    if (!event.target.readyState)
+      throw "Not ready";
+  });
+  socket.addEventListener("close", () => {
+    console.log(`failed to connect to server`);
+    process.exit();
   });
 }
 var { values } = parseArgs({
@@ -28,22 +490,30 @@ var { values } = parseArgs({
     port: {
       type: "string",
       required: true,
-      short: "p",
+      short: "p"
     },
     domain: {
       type: "string",
-      short: "d",
+      default: "localhost:1234",
+      short: "d"
     },
     subdomain: {
       type: "string",
-      short: "s",
+      short: "s"
     },
+    open: {
+      type: "boolean",
+      short: "o"
+    }
   },
-  allowPositionals: true,
+  allowPositionals: true
 });
-if (!values.port) throw "pass -p 3000";
+if (!values.port)
+  throw "pass -p 3000";
+var { port, domain, subdomain, open: open2 } = values;
 main({
-  url: `localhost:${values.port}`,
-  domain: values.domain,
-  subdomain: values.subdomain,
+  url: `localhost:${port}`,
+  domain,
+  subdomain,
+  open: open2
 });

package/client.ts

@@ -21,14 +21,17 @@ async function main({
 
   socket.addEventListener("message", async (event) => {
     const data = JSON.parse(event.data as string);
-    console.log("message:", data);
 
-    if (open && data.url) browser(data.url);
+    if (data.url) {
+      console.log(`\n\n↪ Your URL: \x1b[32m${data.url}\x1b[0m\n`);
+      if (open) browser(data.url);
+    }
 
     if (data.method) {
       const res = await fetch(`${url}${data.pathname}`, {
         method: data.method,
         headers: data.headers,
+        body: data.body,
       });
 
       const { status, statusText, headers } = res;

package/package.json

@@ -4,7 +4,7 @@
   },
   "name": "@rubriclab/bunl",
   "description": "Expose localhost to the world",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
   "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",
     "build": "BUILD=build/client.js && bun build client.ts --outdir build --target node && echo -e \"#! /usr/bin/env bun\n$(cat $BUILD)\" > $BUILD"

package/server.ts

@@ -34,8 +34,11 @@ serve<Client>({
     // 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);
-    client.send(JSON.stringify({ method, pathname, headers: reqHeaders }));
+    client.send(
+      JSON.stringify({ method, pathname, body: reqBody, headers: reqHeaders })
+    );
 
     // Wait for the client to cache its response above
     await sleep(1);