bhole 0.1.0-alpha.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> bhole@0.1.0-alpha.0 build E:\Projects\blackhole\packages\cli
+> tsc
+

package/dist/commands/config.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const configCommand: Command;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,eAAO,MAAM,aAAa,SAiCvB,CAAC"}

package/dist/commands/config.js

@@ -0,0 +1,30 @@
+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) => {
+    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}`);
+}));

package/dist/commands/http.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const httpCommand: Command;
+//# sourceMappingURL=http.d.ts.map

package/dist/commands/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/commands/http.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwDpC,eAAO,MAAM,WAAW,SA2DpB,CAAC"}

package/dist/commands/http.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import net from "net";
+import { Command } from "commander";
+import { loadConfig } from "../config.js";
+import { runTunnelPlain } from "../lib/tunnelPlain.js";
+import { randomMnemonicId } from "../lib/words.js";
+const authToken = process.env.BHOLE_AUTH_TOKEN;
+function isPortListening(port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 500);
+        socket.on("connect", () => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.on("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+        socket.connect(port, "127.0.0.1");
+    });
+}
+async function runTunnel(serverUrl, endpoint, localPort, publicUrl, tunnelDomain) {
+    if (process.stdin.isTTY) {
+        const { render } = await import("ink");
+        const { TunnelApp } = await import("../ui/TunnelApp.js");
+        const { waitUntilExit } = render(_jsx(TunnelApp, { serverUrl: serverUrl, endpoint: endpoint, localPort: localPort, publicUrl: publicUrl, tunnelDomain: tunnelDomain, authToken: authToken, onExit: (code) => process.exit(code) }));
+        await waitUntilExit();
+    }
+    else {
+        await runTunnelPlain(serverUrl, endpoint, localPort, publicUrl, authToken);
+    }
+}
+export const httpCommand = new Command("http")
+    .description("Expose a local HTTP server to the internet")
+    .argument("<port>", "Local port to expose")
+    .option("-s, --server <url>", "Tunnel server URL (default: ws://localhost:8080)", "ws://localhost:8080")
+    .option("-d, --domain <domain>", "Static subdomain (e.g. --domain=myapp)")
+    .option("--subdomain <name>", "Custom subdomain (alias for --domain)")
+    .action(async (portStr, options) => {
+    const port = parseInt(portStr, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error("Error: port must be a valid number between 1 and 65535");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const tunnelDomain = config.tunnelDomain ?? process.env.BHOLE_TUNNEL_DOMAIN;
+    let serverUrl = (options.server || process.env.BHOLE_SERVER_URL || "ws://localhost:8080").replace(/^http/, "ws");
+    if (!serverUrl.startsWith("ws"))
+        serverUrl = "ws://" + serverUrl;
+    if (!tunnelDomain && !serverUrl.includes("localhost")) {
+        console.error("Error: Set tunnel domain with 'bhole config set-tunnel-domain <domain>' or BHOLE_TUNNEL_DOMAIN");
+        process.exit(1);
+    }
+    const effectiveDomain = tunnelDomain ?? "localhost";
+    const domainOrSub = options.domain ?? options.subdomain;
+    let endpoint;
+    let publicUrl;
+    if (domainOrSub) {
+        let hostname = domainOrSub.trim();
+        if (hostname.startsWith("http://") || hostname.startsWith("https://")) {
+            try {
+                hostname = new URL(hostname).hostname;
+            }
+            catch {
+                hostname = domainOrSub;
+            }
+        }
+        if (hostname.includes(".")) {
+            endpoint = hostname.split(".")[0] ?? hostname;
+            publicUrl = domainOrSub.startsWith("http") ? domainOrSub : `https://${hostname}`;
+        }
+        else {
+            endpoint = hostname;
+            publicUrl = `https://${endpoint}.${effectiveDomain}`;
+        }
+        if (!endpoint || endpoint.length > 63) {
+            console.error("Error: endpoint must be 1–63 characters");
+            process.exit(1);
+        }
+    }
+    else {
+        endpoint = randomMnemonicId();
+        publicUrl = `https://${endpoint}.${effectiveDomain}`;
+    }
+    const portOk = await isPortListening(port);
+    if (!portOk) {
+        console.warn(`Note: Nothing appears to be listening on localhost:${port}. Requests will return 502 until your server is running.`);
+    }
+    await runTunnel(serverUrl, endpoint, port, publicUrl, effectiveDomain);
+});

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const loginCommand: Command;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBpC,eAAO,MAAM,YAAY,SAUrB,CAAC"}

package/dist/commands/login.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from "commander";
+import { runLoginPlain } from "../lib/loginPlain.js";
+const DEFAULT_SITE_URL = process.env.BHOLE_SITE_URL ?? "http://localhost:2465";
+async function runLogin(siteUrl, apiKey) {
+    if (process.stdin.isTTY) {
+        const { render } = await import("ink");
+        const { LoginApp } = await import("../ui/LoginApp.js");
+        const { waitUntilExit } = render(_jsx(LoginApp, { siteUrl: siteUrl, apiKey: apiKey, onExit: (code) => process.exit(code) }));
+        await waitUntilExit();
+    }
+    else {
+        const code = await runLoginPlain(siteUrl, apiKey);
+        process.exit(code);
+    }
+}
+export const loginCommand = new Command("login")
+    .description("Sign in and store your API key for tunneling")
+    .option("-u, --url <url>", "Dashboard URL to open", DEFAULT_SITE_URL)
+    .argument("[apiKey]", "API key from the dashboard (optional - will open browser if not provided)")
+    .action(async (apiKey, options) => {
+    const siteUrl = options?.url ?? process.env.BHOLE_SITE_URL ?? DEFAULT_SITE_URL;
+    await runLogin(siteUrl, apiKey);
+});

package/dist/commands/logout.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const logoutCommand: Command;
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../src/commands/logout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,eAAO,MAAM,aAAa,SAoCtB,CAAC"}

package/dist/commands/logout.js

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { loadConfig, saveConfig } from "../config.js";
+const DEFAULT_SITE_URL = process.env.BHOLE_SITE_URL ?? "http://localhost:2465";
+export const logoutCommand = new Command("logout")
+    .description("Sign out and clear stored API key")
+    .option("-u, --url <url>", "Dashboard URL", DEFAULT_SITE_URL)
+    .action(async (options) => {
+    const config = loadConfig();
+    if (!config.apiKey) {
+        console.log("You are not signed in.");
+        return;
+    }
+    const siteUrl = options?.url ?? config.siteUrl ?? DEFAULT_SITE_URL;
+    const baseUrl = siteUrl.replace(/\/$/, "");
+    const apiKey = config.apiKey;
+    delete config.apiKey;
+    saveConfig(config);
+    try {
+        const res = await fetch(`${baseUrl}/api/cli-auth/revoke`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key: apiKey }),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            if (data.revoked) {
+                console.log("Signed out and API key revoked.");
+            }
+            else {
+                console.log("Signed out successfully.");
+            }
+        }
+        else {
+            console.log("Signed out successfully.");
+        }
+    }
+    catch {
+        console.log("Signed out successfully.");
+    }
+});

package/dist/commands/tcp.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const tcpCommand: Command;
+//# sourceMappingURL=tcp.d.ts.map

package/dist/commands/tcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcp.d.ts","sourceRoot":"","sources":["../../src/commands/tcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,eAAO,MAAM,UAAU,SAQnB,CAAC"}

package/dist/commands/tcp.js

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+export const tcpCommand = new Command("tcp")
+    .description("Expose a local TCP port to the internet (coming soon)")
+    .argument("<port>", "Local port to expose")
+    .option("-s, --server <url>", "Blackhole server URL", "ws://localhost:8081")
+    .option("--subdomain <name>", "Custom subdomain for the tunnel")
+    .action((_portStr) => {
+    console.log("TCP tunneling is not yet implemented. Use 'bhole http <port>' for HTTP.");
+    process.exit(1);
+});

package/dist/commands/whoami.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const whoamiCommand: Command;
+//# sourceMappingURL=whoami.d.ts.map

package/dist/commands/whoami.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,eAAO,MAAM,aAAa,SAoCtB,CAAC"}

package/dist/commands/whoami.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { loadConfig } from "../config.js";
+const DEFAULT_SITE_URL = process.env.BHOLE_SITE_URL ?? "http://localhost:2465";
+export const whoamiCommand = new Command("whoami")
+    .description("Show current signed-in identity")
+    .option("-u, --url <url>", "Dashboard URL", DEFAULT_SITE_URL)
+    .action(async (options) => {
+    const config = loadConfig();
+    if (!config.apiKey) {
+        console.log("You are not signed in.");
+        console.log("Run bhole login to sign in.");
+        return;
+    }
+    const siteUrl = options?.url ?? config.siteUrl ?? DEFAULT_SITE_URL;
+    const baseUrl = siteUrl.replace(/\/$/, "");
+    console.log("Signed in");
+    console.log("API key:", "***" + config.apiKey.slice(-4));
+    if (config.siteUrl) {
+        console.log("Dashboard:", config.siteUrl);
+    }
+    try {
+        const res = await fetch(`${baseUrl}/api/whoami`, {
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+        });
+        if (res.ok) {
+            const user = (await res.json());
+            const display = user.name || user.email;
+            if (display) {
+                console.log("User:", display);
+            }
+        }
+    }
+    catch {
+        // Silently ignore - we already showed key/site
+    }
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface Config {
+    /** Public domain for tunnel URLs. Tunnels are reachable at https://{endpoint}.{tunnelDomain} */
+    tunnelDomain?: string;
+}
+export declare function getConfigDir(): string;
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Config): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,MAAM;IACrB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,UAAU,IAAI,MAAM,CAOnC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAe/C"}

package/dist/config.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import path from "path";
+import { homedir } from "os";
+const CONFIG_DIR = path.join(homedir(), ".blackhole");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function loadConfig() {
+    try {
+        const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+        try {
+            fs.chmodSync(CONFIG_DIR, 0o700);
+            fs.chmodSync(CONFIG_FILE, 0o600);
+        }
+        catch {
+            // chmod may no-op on some platforms (e.g. Windows); ignore
+        }
+    }
+    catch (err) {
+        throw new Error(`Failed to save config: ${err}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { configCommand } from "./commands/config.js";
+import { httpCommand } from "./commands/http.js";
+import { tcpCommand } from "./commands/tcp.js";
+import { CLI_VERSION } from "./lib/version.js";
+const program = new Command();
+program
+    .name("bhole")
+    .description("Expose local services to the internet - tunnel localhost with one command")
+    .version(CLI_VERSION);
+program.addCommand(configCommand);
+program.addCommand(httpCommand);
+program.addCommand(tcpCommand);
+program.parse();

package/dist/lib/loginPlain.d.ts

@@ -0,0 +1,2 @@
+export declare function runLoginPlain(siteUrl: string, apiKey?: string): Promise<number>;
+//# sourceMappingURL=loginPlain.d.ts.map

package/dist/lib/loginPlain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loginPlain.d.ts","sourceRoot":"","sources":["../../src/lib/loginPlain.ts"],"names":[],"mappings":"AAKA,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CA+EjB"}

package/dist/lib/loginPlain.js

@@ -0,0 +1,76 @@
+import { loadConfig, saveConfig } from "../config.js";
+const POLL_INTERVAL_MS = 1500;
+const MAX_WAIT_MS = 10 * 60 * 1000;
+export async function runLoginPlain(siteUrl, apiKey) {
+    const baseUrl = siteUrl.replace(/\/$/, "");
+    const config = loadConfig();
+    if (!apiKey?.trim() && config.apiKey) {
+        console.log("You are already signed in.");
+        console.log("API key: ***" + config.apiKey.slice(-4));
+        console.log("Run bhole logout to sign out.");
+        return 0;
+    }
+    if (apiKey?.trim()) {
+        const key = apiKey.trim();
+        if (!key.startsWith("bh_")) {
+            console.error("Invalid API key format. Keys should start with bh_");
+            return 1;
+        }
+        config.apiKey = key;
+        config.siteUrl = siteUrl;
+        saveConfig(config);
+        console.log("API key saved successfully.");
+        console.log("You can now run: bhole http 3000");
+        return 0;
+    }
+    try {
+        const startRes = await fetch(`${baseUrl}/api/cli-auth/start`, { method: "POST" });
+        if (!startRes.ok) {
+            console.error("Failed to start login. Is the dashboard running?");
+            return 1;
+        }
+        const { code } = (await startRes.json());
+        if (!code) {
+            console.error("Invalid response from dashboard.");
+            return 1;
+        }
+        const cliAuthUrl = `${baseUrl}/cli-auth?code=${code}`;
+        console.log("");
+        console.log("  Open this URL to sign in:");
+        console.log(`  ${cliAuthUrl}`);
+        console.log("");
+        try {
+            const { default: open } = await import("open");
+            await open(cliAuthUrl);
+        }
+        catch {
+            console.log("  (Could not open browser automatically)");
+        }
+        console.log("  Waiting for you to complete sign-in in the browser...");
+        const deadline = Date.now() + MAX_WAIT_MS;
+        while (Date.now() < deadline) {
+            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);
+                console.log("API key saved successfully.");
+                console.log("You can now run: bhole http 3000");
+                return 0;
+            }
+            if (data.status === "expired" || data.status === "invalid") {
+                console.error("Login expired or invalid. Run bhole login again.");
+                return 1;
+            }
+        }
+        console.error("Login timed out. Run bhole login again.");
+        return 1;
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : "Login failed.");
+        return 1;
+    }
+}

package/dist/lib/tunnelPlain.d.ts

@@ -0,0 +1,2 @@
+export declare function runTunnelPlain(serverUrl: string, endpoint: string, localPort: number, publicUrl: string, authToken?: string): Promise<void>;
+//# sourceMappingURL=tunnelPlain.d.ts.map

package/dist/lib/tunnelPlain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnelPlain.d.ts","sourceRoot":"","sources":["../../src/lib/tunnelPlain.ts"],"names":[],"mappings":"AAKA,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/lib/tunnelPlain.js

@@ -0,0 +1,31 @@
+import { createHttpTunnel } from "../tunnel/http.js";
+const MAX_RETRIES = 2;
+const BASE_DELAY_MS = 2000;
+export async function runTunnelPlain(serverUrl, endpoint, localPort, publicUrl, authToken) {
+    const wsUrl = serverUrl.replace(/^http/, "ws");
+    console.log(`Connecting to ${wsUrl}...`);
+    console.log(`Exposing localhost:${localPort} at ${publicUrl}`);
+    const tryConnect = (attempt) => new Promise((resolve, reject) => {
+        createHttpTunnel({ serverUrl: wsUrl, endpoint, localPort, authToken }, {
+            onReady: () => {
+                console.log("Tunnel established. Forwarding traffic to localhost:" + localPort);
+                console.log(`URL: ${publicUrl}`);
+                console.log(`(or use X-Blackhole-Endpoint: ${endpoint})`);
+                resolve();
+            },
+            onError: (err) => {
+                console.error("Tunnel error:", err.message);
+            },
+        }).catch((err) => {
+            if (attempt < MAX_RETRIES) {
+                const delayMs = BASE_DELAY_MS * Math.pow(2, attempt);
+                console.error(`Connection failed. Retrying in ${delayMs / 1000}s...`);
+                setTimeout(() => tryConnect(attempt + 1).then(resolve, reject), delayMs);
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+    tryConnect(0).catch(() => process.exit(1));
+}

package/dist/lib/version.d.ts

@@ -0,0 +1,4 @@
+export declare const CLI_VERSION: string;
+export declare function getLatestVersion(): Promise<string | null>;
+export declare function shouldSuggestUpdate(latest: string | null): boolean;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,QAAc,CAAC;AAoBvC,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAW/D;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAGlE"}

package/dist/lib/version.js

@@ -0,0 +1,44 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const pkg = require(path.join(__dirname, "../../package.json"));
+export const CLI_VERSION = pkg.version;
+/** Compare semver strings. Returns true if a > b. */
+function isNewer(a, b) {
+    const parse = (s) => s
+        .replace(/[-].*$/, "")
+        .split(".")
+        .map((n) => parseInt(n, 10) || 0);
+    const pa = parse(a);
+    const pb = parse(b);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const va = pa[i] ?? 0;
+        const vb = pb[i] ?? 0;
+        if (va > vb)
+            return true;
+        if (va < vb)
+            return false;
+    }
+    return false;
+}
+export async function getLatestVersion() {
+    try {
+        const res = await fetch("https://registry.npmjs.org/bhole/latest", {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function shouldSuggestUpdate(latest) {
+    if (!latest)
+        return false;
+    return isNewer(latest, CLI_VERSION);
+}

package/dist/lib/words.d.ts

@@ -0,0 +1,2 @@
+export declare function randomMnemonicId(): string;
+//# sourceMappingURL=words.d.ts.map

package/dist/lib/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../../src/lib/words.ts"],"names":[],"mappings":"AAkBA,wBAAgB,gBAAgB,IAAI,MAAM,CAMzC"}

package/dist/lib/words.js

@@ -0,0 +1,24 @@
+/**
+ * Mnemonic word list for ngrok-style random subdomains (e.g. happy-blue-frog).
+ * Short, memorable, URL-safe words.
+ */
+const WORDS = [
+    "angel", "apple", "arrow", "beach", "bear", "bird", "blue", "boat", "bold",
+    "bone", "book", "boss", "bush", "cake", "cash", "cat", "cave", "cold",
+    "cord", "crab", "cube", "dark", "demo", "dice", "dock", "door", "dove",
+    "dusk", "edge", "echo", "elm", "fall", "fern", "fire", "fish", "flag",
+    "flat", "fog", "fork", "frog", "gold", "gray", "grey", "grid", "gulf",
+    "harp", "hill", "hope", "iris", "iron", "java", "jazz", "key", "kite",
+    "lake", "lamp", "lane", "leaf", "lime", "lion", "log", "map", "mask",
+    "mint", "mist", "moon", "nova", "oak", "ocean", "olive", "opal", "pine",
+    "pink", "pool", "port", "rain", "reed", "rock", "rose", "rust", "sand",
+    "seed", "sky", "snow", "star", "sun", "surf", "swan", "tide", "tree",
+    "vine", "wave", "wolf", "wood", "zen",
+];
+export function randomMnemonicId() {
+    const picks = [];
+    for (let i = 0; i < 3; i++) {
+        picks.push(WORDS[Math.floor(Math.random() * WORDS.length)]);
+    }
+    return picks.join("-");
+}

package/dist/tunnel/http.d.ts

@@ -0,0 +1,23 @@
+export interface HttpTunnelOptions {
+    serverUrl: string;
+    endpoint: string;
+    localPort: number;
+    /** Shared secret for auth (from BHOLE_AUTH_TOKEN) */
+    authToken?: string;
+}
+export interface TunnelRequestInfo {
+    method: string;
+    path: string;
+    bytesIn: number;
+    bytesOut: number;
+    statusCode?: number;
+    timestamp: Date;
+}
+export interface HttpTunnelCallbacks {
+    onOpen?: () => void;
+    onReady?: () => void;
+    onRequest?: (info: TunnelRequestInfo) => void;
+    onError?: (err: Error) => void;
+}
+export declare function createHttpTunnel(options: HttpTunnelOptions, callbacks?: HttpTunnelCallbacks): Promise<void>;
+//# sourceMappingURL=http.d.ts.map

package/dist/tunnel/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/tunnel/http.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC9C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAChC;AAQD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,iBAAiB,EAC1B,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAgJf"}