bhole 0.1.0-alpha.0

package/dist/tunnel/http.js

@@ -0,0 +1,267 @@
+import http from "http";
+import WebSocket from "ws";
+const REGISTER_TIMEOUT_MS = 15000;
+const LOCAL_FORWARD_TIMEOUT_MS = 30000;
+const CONNECT_TIMEOUT_MS = 10000;
+const MAX_REQUEST_BODY_BYTES = 10 * 1024 * 1024; // 10MB
+const MAX_RESPONSE_BODY_BYTES = 10 * 1024 * 1024; // 10MB
+export function createHttpTunnel(options, callbacks) {
+    return new Promise((resolve, reject) => {
+        let rejected = false;
+        const doReject = (err) => {
+            if (rejected)
+                return;
+            rejected = true;
+            callbacks?.onError?.(err);
+            reject(err);
+        };
+        const ws = new WebSocket(options.serverUrl + "/tunnel");
+        let registerTimeout = null;
+        let connectTimeout = null;
+        let ready = false;
+        const clearRegisterTimeout = () => {
+            if (registerTimeout) {
+                clearTimeout(registerTimeout);
+                registerTimeout = null;
+            }
+        };
+        const safeSend = (data, opts) => {
+            if (ws.readyState === 1) {
+                try {
+                    if (opts)
+                        ws.send(data, opts);
+                    else
+                        ws.send(data);
+                }
+                catch (err) {
+                    if (!rejected)
+                        doReject(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+        };
+        connectTimeout = setTimeout(() => {
+            if (ready || rejected)
+                return;
+            connectTimeout = null;
+            ws.terminate();
+            doReject(new Error("Connection timed out – server unreachable."));
+        }, CONNECT_TIMEOUT_MS);
+        ws.on("open", () => {
+            if (connectTimeout) {
+                clearTimeout(connectTimeout);
+                connectTimeout = null;
+            }
+            callbacks?.onOpen?.();
+            const msg = { type: "register", endpoint: options.endpoint };
+            if (options.authToken)
+                msg.authToken = options.authToken;
+            safeSend(JSON.stringify(msg));
+            registerTimeout = setTimeout(() => {
+                if (!ready) {
+                    clearRegisterTimeout();
+                    const err = new Error("Registration timed out – server may be busy. Try again.");
+                    doReject(err);
+                    ws.close();
+                }
+            }, REGISTER_TIMEOUT_MS);
+        });
+        ws.on("message", (data) => {
+            const str = data.toString();
+            if (str.startsWith("{")) {
+                try {
+                    const msg = JSON.parse(str);
+                    if (msg.error) {
+                        ready = true;
+                        clearRegisterTimeout();
+                        const err = new Error(msg.error || "Server error");
+                        doReject(err);
+                        ws.close();
+                        return;
+                    }
+                    if (msg.ok) {
+                        ready = true;
+                        clearRegisterTimeout();
+                        callbacks?.onReady?.();
+                    }
+                    return;
+                }
+                catch {
+                    // Not JSON, treat as binary (request from server)
+                }
+            }
+            if (Buffer.isBuffer(data) || typeof data !== "string") {
+                const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                if (buf.length > MAX_REQUEST_BODY_BYTES) {
+                    const errResp = `HTTP/1.1 413 Payload Too Large\r\nContent-Type: text/plain\r\n\r\nRequest body exceeds ${MAX_REQUEST_BODY_BYTES / (1024 * 1024)}MB limit`;
+                    safeSend(Buffer.from(errResp));
+                    return;
+                }
+                const req = parseHttpRequest(buf);
+                if (!req) {
+                    const errResp = "HTTP/1.1 400 Bad Request\r\nContent-Type: text/plain\r\n\r\nFailed to parse request";
+                    safeSend(Buffer.from(errResp));
+                    return;
+                }
+                forwardToLocal(buf, options.localPort)
+                    .then((response) => {
+                    const info = parseResponseStatus(response);
+                    callbacks?.onRequest?.({
+                        method: req.method,
+                        path: req.path,
+                        bytesIn: buf.length,
+                        bytesOut: response.length,
+                        statusCode: info?.statusCode,
+                        timestamp: new Date(),
+                    });
+                    safeSend(response, { binary: true });
+                })
+                    .catch((err) => {
+                    callbacks?.onRequest?.({
+                        method: req.method,
+                        path: req.path,
+                        bytesIn: buf.length,
+                        bytesOut: 0,
+                        timestamp: new Date(),
+                    });
+                    const errResp = `HTTP/1.1 502 Bad Gateway\r\nContent-Type: text/plain\r\n\r\n${err.message}`;
+                    safeSend(Buffer.from(errResp));
+                });
+            }
+        });
+        ws.on("error", (err) => {
+            clearRegisterTimeout();
+            if (connectTimeout) {
+                clearTimeout(connectTimeout);
+                connectTimeout = null;
+            }
+            const msg = err.message || String(err) || "Connection failed";
+            doReject(new Error(msg));
+        });
+        ws.on("close", () => {
+            clearRegisterTimeout();
+            if (connectTimeout) {
+                clearTimeout(connectTimeout);
+                connectTimeout = null;
+            }
+            if (ready && !rejected) {
+                doReject(new Error("Connection closed"));
+            }
+        });
+    });
+}
+async function forwardToLocal(rawRequest, localPort) {
+    return new Promise((resolve, reject) => {
+        const req = parseHttpRequest(rawRequest);
+        if (!req) {
+            reject(new Error("Failed to parse request"));
+            return;
+        }
+        const opts = {
+            hostname: "localhost",
+            port: localPort,
+            path: req.path,
+            method: req.method,
+            headers: req.headers,
+        };
+        const timeout = setTimeout(() => {
+            proxyReq.destroy(new Error("Local server did not respond in time"));
+        }, LOCAL_FORWARD_TIMEOUT_MS);
+        const proxyReq = http.request(opts, (res) => {
+            clearTimeout(timeout);
+            const chunks = [];
+            let totalBytes = 0;
+            let responseExceeded = false;
+            const exceededResponse = () => Buffer.from(`HTTP/1.1 502 Bad Gateway\r\nContent-Type: text/plain\r\n\r\nResponse body exceeds ${MAX_RESPONSE_BODY_BYTES / (1024 * 1024)}MB limit`);
+            const finish = (buf) => {
+                clearTimeout(timeout);
+                resolve(buf);
+            };
+            res.on("data", (chunk) => {
+                if (responseExceeded)
+                    return;
+                if (totalBytes + chunk.length <= MAX_RESPONSE_BODY_BYTES) {
+                    chunks.push(chunk);
+                    totalBytes += chunk.length;
+                }
+                else {
+                    responseExceeded = true;
+                    res.destroy();
+                    finish(exceededResponse());
+                }
+            });
+            res.on("end", () => {
+                if (responseExceeded)
+                    return;
+                const statusLine = `HTTP/1.1 ${res.statusCode} ${res.statusMessage}\r\n`;
+                const headers = Object.entries(res.headers)
+                    .filter(([, v]) => v !== undefined)
+                    .map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(", ") : v}\r\n`)
+                    .join("");
+                const body = Buffer.concat(chunks);
+                finish(Buffer.concat([Buffer.from(statusLine + headers + "\r\n"), body]));
+            });
+            res.on("error", (err) => {
+                if (!responseExceeded) {
+                    clearTimeout(timeout);
+                    reject(err);
+                }
+            });
+        });
+        proxyReq.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+        proxyReq.end(req.body);
+    });
+}
+function parseRequestMethod(buf) {
+    const firstLine = buf.subarray(0, buf.indexOf("\n")).toString();
+    return firstLine.split(" ")[0] ?? "?";
+}
+function parseRequestPath(buf) {
+    const firstLine = buf.subarray(0, buf.indexOf("\n")).toString();
+    const path = firstLine.split(" ")[1];
+    return path ?? "/";
+}
+function parseResponseStatus(buf) {
+    const firstLine = buf.subarray(0, buf.indexOf("\n")).toString();
+    const parts = firstLine.split(" ");
+    const code = parseInt(parts[1] ?? "0", 10);
+    return isNaN(code) ? null : { statusCode: code };
+}
+function parseHttpRequest(buf) {
+    const idx = buf.indexOf("\r\n\r\n");
+    const idxLf = buf.indexOf("\n\n");
+    const sepIdx = idx >= 0 ? idx : idxLf >= 0 ? idxLf : -1;
+    const sepLen = idx >= 0 ? 4 : idxLf >= 0 ? 2 : 0;
+    if (sepIdx === -1)
+        return null;
+    const headerSection = buf.subarray(0, sepIdx).toString();
+    const body = buf.subarray(sepIdx + sepLen);
+    const lineSep = idx >= 0 ? "\r\n" : "\n";
+    const lines = headerSection.split(lineSep);
+    const firstLine = lines[0];
+    if (!firstLine)
+        return null;
+    const parts = firstLine.split(" ");
+    const method = parts[0] ?? "GET";
+    const path = parts[1] ?? "/";
+    const headers = {};
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const colon = line.indexOf(":");
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim().toLowerCase();
+        const value = line.slice(colon + 1).trim();
+        headers[key] = value;
+    }
+    return {
+        method,
+        path,
+        headers,
+        body,
+    };
+}

package/dist/ui/LoginApp.d.ts

@@ -0,0 +1,8 @@
+interface LoginAppProps {
+    siteUrl: string;
+    apiKey?: string;
+    onExit: (code: number) => void;
+}
+export declare function LoginApp({ siteUrl, apiKey, onExit }: LoginAppProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=LoginApp.d.ts.map

package/dist/ui/LoginApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoginApp.d.ts","sourceRoot":"","sources":["../../src/ui/LoginApp.tsx"],"names":[],"mappings":"AAgBA,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,wBAAgB,QAAQ,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,aAAa,kDA4MlE"}

package/dist/ui/LoginApp.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { loadConfig, saveConfig } from "../config.js";
+const DEFAULT_SITE_URL = process.env.BHOLE_SITE_URL ?? "http://localhost:2465";
+const POLL_INTERVAL_MS = 1500;
+const MAX_WAIT_MS = 10 * 60 * 1000;
+export function LoginApp({ siteUrl, apiKey, onExit }) {
+    const [status, setStatus] = useState({ type: "starting" });
+    const [retryAfterSignOut, setRetryAfterSignOut] = useState(0);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            onExit(1);
+            return;
+        }
+        if (status.type === "alreadyLoggedIn") {
+            if (input.toLowerCase() === "s") {
+                const config = loadConfig();
+                delete config.apiKey;
+                saveConfig(config);
+                setStatus({ type: "starting" });
+                setRetryAfterSignOut((r) => r + 1);
+                return;
+            }
+            if (key.return) {
+                onExit(0);
+            }
+        }
+    });
+    useEffect(() => {
+        const baseUrl = siteUrl.replace(/\/$/, "");
+        const config = loadConfig();
+        if (!apiKey?.trim() && config.apiKey && retryAfterSignOut === 0) {
+            setStatus({
+                type: "alreadyLoggedIn",
+                keyMask: "***" + config.apiKey.slice(-4),
+            });
+            return;
+        }
+        if (apiKey?.trim()) {
+            const key = apiKey.trim();
+            if (!key.startsWith("bh_")) {
+                setStatus({ type: "error", message: "Invalid API key format. Keys should start with bh_" });
+                return;
+            }
+            config.apiKey = key;
+            config.siteUrl = siteUrl;
+            saveConfig(config);
+            setStatus({ type: "success" });
+            setTimeout(() => onExit(0), 1500);
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const startRes = await fetch(`${baseUrl}/api/cli-auth/start`, { method: "POST" });
+                if (cancelled)
+                    return;
+                if (!startRes.ok) {
+                    setStatus({ type: "error", message: "Failed to start login. Is the dashboard running?" });
+                    return;
+                }
+                const { code } = (await startRes.json());
+                if (!code) {
+                    setStatus({ type: "error", message: "Invalid response from dashboard." });
+                    return;
+                }
+                const cliAuthUrl = `${baseUrl}/cli-auth?code=${code}`;
+                let opened = false;
+                try {
+                    const { default: open } = await import("open");
+                    await open(cliAuthUrl);
+                    opened = true;
+                }
+                catch {
+                    // Browser didn't open
+                }
+                setStatus({ type: "ready", url: cliAuthUrl, opened });
+                const deadline = Date.now() + MAX_WAIT_MS;
+                while (Date.now() < deadline && !cancelled) {
+                    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                    const statusRes = await fetch(`${baseUrl}/api/cli-auth/status?code=${encodeURIComponent(code)}`);
+                    const data = (await statusRes.json());
+                    if (data.status === "ready" && data.apiKey) {
+                        const config = loadConfig();
+                        config.apiKey = data.apiKey;
+                        config.siteUrl = siteUrl;
+                        saveConfig(config);
+                        setStatus({ type: "success" });
+                        setTimeout(() => onExit(0), 1500);
+                        return;
+                    }
+                    if (data.status === "expired" || data.status === "invalid") {
+                        setStatus({ type: "error", message: "Login expired or invalid. Run bhole login again." });
+                        return;
+                    }
+                }
+                if (!cancelled) {
+                    setStatus({ type: "error", message: "Login timed out. Run bhole login again." });
+                }
+            }
+            catch (e) {
+                if (!cancelled) {
+                    setStatus({ type: "error", message: e instanceof Error ? e.message : "Login failed." });
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [siteUrl, apiKey, onExit, retryAfterSignOut]);
+    if (status.type === "alreadyLoggedIn") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "\u2713 You are already signed in" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "dim", children: ["API key: ", status.keyMask] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "dim", children: "Press S to sign out, Enter to continue" }) })] }));
+    }
+    if (status.type === "starting") {
+        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsx(Box, { children: _jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), " Creating login code..."] }) }) }));
+    }
+    if (status.type === "ready") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "\u2713 Login link ready" }) }, "title"), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "dim", children: "Open this URL to sign in:" }) }, "label"), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "cyan", children: status.url }) }, "url"), !status.opened && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "(Could not open browser automatically)" }) }, "no-browser")), _jsx(Box, { children: _jsxs(Text, { color: "dim", children: [_jsx(Spinner, { type: "dots" }), " Waiting for sign-in..."] }) })] }));
+    }
+    if (status.type === "success") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "\u2713 API key saved successfully" }) }), _jsx(Box, { children: _jsx(Text, { color: "dim", children: "You can now run: bhole http 3000" }) })] }));
+    }
+    if (status.type === "error") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "red", children: ["\u2717 ", status.message] }) }), _jsx(Box, { children: _jsx(Text, { color: "dim", children: "Press Ctrl+C to exit" }) })] }));
+    }
+    return null;
+}

package/dist/ui/TunnelApp.d.ts

@@ -0,0 +1,12 @@
+interface TunnelAppProps {
+    serverUrl: string;
+    endpoint: string;
+    localPort: number;
+    publicUrl: string;
+    tunnelDomain?: string;
+    authToken?: string;
+    onExit: (code: number) => void;
+}
+export declare function TunnelApp({ serverUrl, endpoint, localPort, publicUrl, tunnelDomain, authToken, onExit, }: TunnelAppProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=TunnelApp.d.ts.map

package/dist/ui/TunnelApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TunnelApp.d.ts","sourceRoot":"","sources":["../../src/ui/TunnelApp.tsx"],"names":[],"mappings":"AASA,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAoBD,wBAAgB,SAAS,CAAC,EACxB,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,YAA0B,EAC1B,SAAS,EACT,MAAM,GACP,EAAE,cAAc,2CA8MhB"}

package/dist/ui/TunnelApp.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState, useRef } from "react";
+import { Text, Box, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { createHttpTunnel } from "../tunnel/http.js";
+import { getLatestVersion, shouldSuggestUpdate } from "../lib/version.js";
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+function regionDisplay(region) {
+    const names = {
+        ord: "Chicago",
+        iad: "Virginia",
+        lax: "Los Angeles",
+        gru: "São Paulo",
+        arn: "Stockholm",
+        local: "Local",
+    };
+    return names[region] ?? region;
+}
+export function TunnelApp({ serverUrl, endpoint, localPort, publicUrl, tunnelDomain = "localhost", authToken, onExit, }) {
+    const [status, setStatus] = useState("connecting");
+    const [error, setError] = useState(null);
+    const [requests, setRequests] = useState(0);
+    const [bytesIn, setBytesIn] = useState(0);
+    const [bytesOut, setBytesOut] = useState(0);
+    const [recentRequests, setRecentRequests] = useState([]);
+    const [retryCount, setRetryCount] = useState(0);
+    const [serviceInfo, setServiceInfo] = useState(null);
+    const [latency, setLatency] = useState(null);
+    const [updateAvailable, setUpdateAvailable] = useState(null);
+    const tunnelStarted = useRef(false);
+    const retriesUsed = useRef(0);
+    const maxRetries = 2;
+    const baseDelayMs = 2000;
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            onExit(0);
+        }
+    });
+    useEffect(() => {
+        if (tunnelStarted.current)
+            return;
+        tunnelStarted.current = true;
+        const wsUrl = serverUrl.replace(/^http/, "ws");
+        const tryConnect = () => {
+            setStatus("connecting");
+            setError(null);
+            if (retriesUsed.current > 0) {
+                setRetryCount(retriesUsed.current);
+            }
+            createHttpTunnel({ serverUrl: wsUrl, endpoint, localPort, authToken }, {
+                onOpen: () => setStatus("registering"),
+                onReady: () => setStatus("ready"),
+                onRequest: (info) => {
+                    setRequests((n) => n + 1);
+                    setBytesIn((b) => b + info.bytesIn);
+                    setBytesOut((b) => b + info.bytesOut);
+                    setRecentRequests((prev) => [info, ...prev.slice(0, 4)]);
+                },
+                onError: (err) => {
+                    setError(err.message);
+                    setStatus("error");
+                    if (retriesUsed.current < maxRetries) {
+                        const attempt = retriesUsed.current + 1;
+                        retriesUsed.current = attempt;
+                        const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
+                        setTimeout(() => tryConnect(), delayMs);
+                    }
+                },
+            }).catch(() => {
+                if (retriesUsed.current < maxRetries) {
+                    const attempt = retriesUsed.current + 1;
+                    retriesUsed.current = attempt;
+                    const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
+                    setTimeout(() => tryConnect(), delayMs);
+                }
+            });
+        };
+        tryConnect();
+    }, [serverUrl, endpoint, localPort]);
+    // Fetch account, service info, and measure latency when ready
+    useEffect(() => {
+        if (status !== "ready")
+            return;
+        const host = new URL(serverUrl.replace(/^ws/, "http")).host;
+        const apiBase = serverUrl.includes("localhost")
+            ? "http://localhost:8080"
+            : `https://${host}`;
+        const measureLatency = () => {
+            const start = performance.now();
+            fetch(`${apiBase}/api/health`, { cache: "no-store" })
+                .then((r) => r.json())
+                .then((data) => {
+                const total = Math.round(performance.now() - start);
+                setServiceInfo({ region: data.region ?? "?", version: data.version ?? "?" });
+                setLatency({ up: Math.round(total / 2), down: Math.round(total / 2) });
+            })
+                .catch(() => { });
+        };
+        measureLatency();
+        const latId = setInterval(measureLatency, 10000);
+        getLatestVersion()
+            .then((latest) => {
+            if (shouldSuggestUpdate(latest))
+                setUpdateAvailable(latest);
+        })
+            .catch(() => { });
+        return () => clearInterval(latId);
+    }, [status, serverUrl, tunnelDomain]);
+    if (status === "connecting" || status === "registering") {
+        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsx(Box, { children: _jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), " ", status === "connecting" ? "Connecting" : "Registering tunnel", "...", retryCount > 0 ? (_jsxs(Text, { color: "dim", children: [" (retry ", retryCount, "/", maxRetries, ")"] })) : null] }) }) }));
+    }
+    if (status === "error") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "red", children: ["\u2717 Tunnel error: ", error] }) }), _jsx(Box, { children: _jsx(Text, { color: "dim", children: "Press Ctrl+C to exit" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Status: " }), _jsx(Text, { bold: true, color: "green", children: "Tunnel active" })] }), serviceInfo && (_jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Region: " }), _jsx(Text, { color: "cyan", children: regionDisplay(serviceInfo.region) })] })), latency && (_jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Latency: " }), _jsxs(Text, { color: "cyan", children: [latency.up, "ms"] }), _jsx(Text, { color: "dim", children: " \u2191 " }), _jsxs(Text, { color: "cyan", children: [latency.down, "ms"] }), _jsx(Text, { color: "dim", children: " \u2193" })] })), _jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Forwarding: " }), _jsx(Text, { color: "cyan", children: publicUrl }), _jsx(Text, { color: "dim", children: " \u2192 " }), _jsxs(Text, { color: "green", children: ["localhost:", localPort] })] }), _jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Usage: " }), _jsxs(Text, { color: "cyan", children: ["\u2191", formatBytes(bytesIn)] }), _jsx(Text, { color: "dim", children: " " }), _jsxs(Text, { color: "cyan", children: ["\u2193", formatBytes(bytesOut)] })] }), recentRequests.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "dim", children: "Requests " }), _jsx(Text, { color: "cyan", children: requests })] }), recentRequests.slice(0, 5).map((r, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: "dim", children: ["[", r.timestamp.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" }), "]"] }), _jsx(Text, { color: "dim", children: " " }), _jsx(Text, { color: "cyan", children: r.method }), _jsx(Text, { color: "dim", children: " " }), r.statusCode != null && (_jsxs(_Fragment, { children: [_jsx(Text, { color: r.statusCode >= 400 ? "red" : "green", children: r.statusCode }), _jsx(Text, { color: "dim", children: " " })] })), _jsx(Text, { color: "yellow", children: r.path })] }, i)))] })), updateAvailable && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "Update available: " }), _jsx(Text, { color: "cyan", children: updateAvailable }), _jsx(Text, { color: "dim", children: " \u2014 npm i -g bhole" })] })), _jsx(Box, { children: _jsx(Text, { color: "dim", children: "Press Ctrl+C to stop" }) })] }));
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "bhole",
+  "version": "0.1.0-alpha.0",
+  "type": "module",
+  "description": "Self-hostable ngrok alternative - expose local services to the internet",
+  "bin": {
+    "bhole": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm run build",
+    "prerelease": "npm publish --tag alpha",
+    "release": "npm publish"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "ink": "^6.7.0",
+    "ink-spinner": "^5.0.0",
+    "nanoid": "^5.1.6",
+    "open": "^11.0.0",
+    "react": "^19.2.4",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@blackhole/config-typescript": "workspace:*",
+    "@types/node": "^25.2.3",
+    "@types/react": "^19.2.14",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import { loadConfig, saveConfig, getConfigDir } from "../config.js";
+
+export const configCommand = new Command("config")
+  .description("Manage CLI configuration")
+  .addCommand(
+    new Command("path")
+      .description("Show config file path")
+      .action(() => {
+        console.log(getConfigDir());
+      })
+  )
+  .addCommand(
+    new Command("list")
+      .description("Show current config (key hidden)")
+      .action(() => {
+        const config = loadConfig();
+        console.log("Config location:", getConfigDir());
+        console.log("Tunnel domain:", config.tunnelDomain ?? "(not set — use config set-tunnel-domain)");
+      })
+  )
+  .addCommand(
+    new Command("set-tunnel-domain")
+      .description("Set the public domain for tunnel URLs (e.g. tunnel.yourdomain.com)")
+      .argument("<domain>", "Domain for tunnels (e.g. bhole.link)")
+      .action((domain: string) => {
+        const trimmed = domain.trim().toLowerCase().replace(/^https?:\/\//, "").split("/")[0];
+        if (!trimmed) {
+          console.error("Invalid domain");
+          process.exit(1);
+        }
+        const config = loadConfig();
+        config.tunnelDomain = trimmed;
+        saveConfig(config);
+        console.log(`Tunnel domain set to ${trimmed}. Tunnels will be at https://{endpoint}.${trimmed}`);
+      })
+  );