xpose-dev 1.0.0

package/dist/index.js

@@ -0,0 +1,1494 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+
+// ../../packages/protocol/src/messages.ts
+function isTunnelMessage(data) {
+  return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string";
+}
+function parseTextMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (isTunnelMessage(parsed)) return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/protocol/src/constants.ts
+var PROTOCOL = {
+  /** Length of generated subdomain IDs */
+  SUBDOMAIN_LENGTH: 12,
+  /** Length of random suffix appended to custom subdomains */
+  SUBDOMAIN_SUFFIX_LENGTH: 6,
+  /** Characters used in subdomain IDs (lowercase + digits only for DNS compatibility) */
+  SUBDOMAIN_ALPHABET: "abcdefghijklmnopqrstuvwxyz0123456789",
+  /** Length of request IDs for multiplexing */
+  REQUEST_ID_LENGTH: 12,
+  /** How long to wait for a response from the CLI before timing out */
+  REQUEST_TIMEOUT_MS: 3e4,
+  /** How long to wait for CLI reconnection before rejecting queued requests */
+  RECONNECT_GRACE_PERIOD_MS: 5e3,
+  /** Default request/response body limit: 5MB */
+  DEFAULT_MAX_BODY_SIZE_BYTES: 5 * 1024 * 1024,
+  /** Reconnection backoff parameters */
+  BACKOFF_BASE_MS: 1e3,
+  BACKOFF_MULTIPLIER: 2,
+  BACKOFF_MAX_MS: 3e4,
+  BACKOFF_MAX_ATTEMPTS: 15,
+  BACKOFF_JITTER_MIN: 0.1,
+  BACKOFF_JITTER_MAX: 0.2,
+  /** Default tunnel lifetime: 4 hours */
+  DEFAULT_TTL_SECONDS: 14400,
+  /** Maximum tunnel lifetime: 24 hours */
+  MAX_TTL_SECONDS: 86400,
+  /** Path where CLI connects via WebSocket */
+  TUNNEL_CONNECT_PATH: "/_tunnel/connect",
+  /** Default public tunnel domain */
+  DEFAULT_PUBLIC_DOMAIN: "xpose.dev",
+  /** Auto ping/pong strings for DO WebSocket hibernation */
+  PING_MESSAGE: "ping",
+  PONG_MESSAGE: "pong",
+  /** How long a CLI session can be resumed after exit (seconds) */
+  SESSION_RESUME_WINDOW_SECONDS: 600
+};
+
+// ../../packages/protocol/src/binary.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodeBinaryFrame(requestId, body) {
+  const idBytes = encoder.encode(requestId);
+  const frame = new Uint8Array(PROTOCOL.REQUEST_ID_LENGTH + body.byteLength);
+  frame.set(idBytes, 0);
+  frame.set(body, PROTOCOL.REQUEST_ID_LENGTH);
+  return frame.buffer;
+}
+function decodeBinaryFrame(buffer) {
+  const view = new Uint8Array(buffer);
+  const requestId = decoder.decode(
+    view.slice(0, PROTOCOL.REQUEST_ID_LENGTH)
+  );
+  const body = view.slice(PROTOCOL.REQUEST_ID_LENGTH);
+  return { requestId, body };
+}
+
+// ../../packages/protocol/src/subdomain.ts
+import { customAlphabet } from "nanoid";
+var generateSubdomainId = customAlphabet(
+  PROTOCOL.SUBDOMAIN_ALPHABET,
+  PROTOCOL.SUBDOMAIN_LENGTH
+);
+var generateRequestId = customAlphabet(
+  PROTOCOL.SUBDOMAIN_ALPHABET,
+  PROTOCOL.REQUEST_ID_LENGTH
+);
+var generateSuffix = customAlphabet(
+  PROTOCOL.SUBDOMAIN_ALPHABET,
+  PROTOCOL.SUBDOMAIN_SUFFIX_LENGTH
+);
+function buildCustomSubdomain(prefix) {
+  const sanitized = prefix.toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
+  if (!sanitized) return generateSubdomainId();
+  return `${sanitized}-${generateSuffix()}`;
+}
+
+// src/tunnel-client.ts
+import WebSocket2 from "ws";
+import { EventEmitter } from "events";
+
+// src/ws-relay.ts
+import WebSocket from "ws";
+var WsRelayManager = class {
+  relays = /* @__PURE__ */ new Map();
+  host;
+  port;
+  constructor(host, port) {
+    this.host = host;
+    this.port = port;
+  }
+  /**
+   * Handle a ws-upgrade request from the server: dial the local WebSocket
+   * endpoint and start relaying frames.
+   */
+  handleUpgrade(tunnelWs, msg, sendMessage) {
+    const localUrl = `ws://${this.host}:${this.port}${msg.path}`;
+    const skipHeaders = /* @__PURE__ */ new Set([
+      "host",
+      "upgrade",
+      "connection",
+      "sec-websocket-key",
+      "sec-websocket-version",
+      "sec-websocket-extensions"
+    ]);
+    const headers = {};
+    const subprotocols = [];
+    for (const [key, value] of Object.entries(msg.headers)) {
+      const lower = key.toLowerCase();
+      if (skipHeaders.has(lower)) continue;
+      if (lower === "sec-websocket-protocol") {
+        for (const p of value.split(",")) {
+          const trimmed = p.trim();
+          if (trimmed) subprotocols.push(trimmed);
+        }
+        continue;
+      }
+      headers[lower] = value;
+    }
+    const localConn = new WebSocket(localUrl, subprotocols, { headers });
+    localConn.binaryType = "arraybuffer";
+    localConn.on("error", () => {
+      sendMessage({
+        type: "ws-upgrade-ack",
+        streamId: msg.streamId,
+        ok: false,
+        error: `Failed to connect to ${localUrl}`
+      });
+      this.relays.delete(msg.streamId);
+    });
+    localConn.on("open", () => {
+      const relay = {
+        streamId: msg.streamId,
+        localConn
+      };
+      this.relays.set(msg.streamId, relay);
+      sendMessage({
+        type: "ws-upgrade-ack",
+        streamId: msg.streamId,
+        ok: true
+      });
+      this.readLocalAndForward(tunnelWs, relay, sendMessage);
+    });
+    localConn.on("close", () => {
+      if (!this.relays.has(msg.streamId)) return;
+      sendMessage({
+        type: "ws-close",
+        streamId: msg.streamId,
+        code: 1e3,
+        reason: "Local WebSocket closed"
+      });
+      this.relays.delete(msg.streamId);
+    });
+  }
+  /**
+   * Read frames from the local WebSocket and forward them through the tunnel.
+   */
+  readLocalAndForward(tunnelWs, relay, sendMessage) {
+    relay.localConn.on("message", (data, isBinary) => {
+      if (!this.relays.has(relay.streamId)) return;
+      const frameType = isBinary ? "binary" : "text";
+      sendMessage({
+        type: "ws-frame",
+        streamId: relay.streamId,
+        frameType
+      });
+      let body;
+      if (Buffer.isBuffer(data)) {
+        body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else if (data instanceof ArrayBuffer) {
+        body = new Uint8Array(data);
+      } else if (typeof data === "string") {
+        body = new TextEncoder().encode(data);
+      } else {
+        body = Buffer.concat(data);
+      }
+      const frame = encodeBinaryFrame(relay.streamId, body);
+      tunnelWs.send(frame);
+    });
+  }
+  /**
+   * Forward a WS frame from the browser (via tunnel) to the local WS.
+   */
+  handleFrame(msg, body) {
+    const relay = this.relays.get(msg.streamId);
+    if (!relay) return;
+    if (msg.frameType === "text") {
+      const text = new TextDecoder().decode(body);
+      relay.localConn.send(text);
+    } else {
+      relay.localConn.send(body);
+    }
+  }
+  /**
+   * Close a relay stream.
+   */
+  handleClose(msg) {
+    this.closeRelay(msg.streamId);
+  }
+  /**
+   * Tear down a single relay connection.
+   */
+  closeRelay(streamId) {
+    const relay = this.relays.get(streamId);
+    if (!relay) return;
+    this.relays.delete(streamId);
+    try {
+      relay.localConn.close(1e3, "Stream closed");
+    } catch {
+    }
+  }
+  /**
+   * Tear down all active relay connections.
+   */
+  closeAll() {
+    for (const relay of this.relays.values()) {
+      try {
+        relay.localConn.close(1e3, "All streams closed");
+      } catch {
+      }
+    }
+    this.relays.clear();
+  }
+};
+
+// src/tunnel-client.ts
+function parseContentLength(raw) {
+  if (!raw) return null;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return null;
+  return parsed;
+}
+function headerValue(headers, name) {
+  const target = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === target) return value;
+  }
+  return void 0;
+}
+function toArrayBuffer(view) {
+  return view.buffer.slice(
+    view.byteOffset,
+    view.byteOffset + view.byteLength
+  );
+}
+function createTunnelClient(opts) {
+  const emitter = new EventEmitter();
+  let ws = null;
+  let reconnectAttempts = 0;
+  let sessionId = null;
+  let disconnectedIntentionally = false;
+  let maxBodySizeBytes = PROTOCOL.DEFAULT_MAX_BODY_SIZE_BYTES;
+  const requestBodyChunks = /* @__PURE__ */ new Map();
+  const requestBodySizes = /* @__PURE__ */ new Map();
+  const oversizedRequestIds = /* @__PURE__ */ new Set();
+  const pendingRequestMeta = /* @__PURE__ */ new Map();
+  const wsRelayMgr = new WsRelayManager(opts.host, opts.port);
+  const pendingWsFrameTypes = /* @__PURE__ */ new Map();
+  const tunnelDomain = opts.domain?.trim() || PROTOCOL.DEFAULT_PUBLIC_DOMAIN;
+  const wsUrl = `wss://${opts.subdomain}.${tunnelDomain}${PROTOCOL.TUNNEL_CONNECT_PATH}`;
+  function emitStatus(status) {
+    emitter.emit("status", status);
+  }
+  function sendMessage(message) {
+    ws?.send(JSON.stringify(message));
+  }
+  async function readBodyWithinLimit(body) {
+    if (!body) {
+      return { chunks: [], totalBytes: 0 };
+    }
+    const chunks = [];
+    let totalBytes = 0;
+    const reader = body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        totalBytes += value.byteLength;
+        if (totalBytes > maxBodySizeBytes) {
+          return null;
+        }
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return { chunks, totalBytes };
+  }
+  function respondWith413(requestId, message) {
+    sendMessage({
+      type: "error",
+      message,
+      requestId,
+      status: 413
+    });
+  }
+  function handleBinaryFrame(data) {
+    const { requestId, body } = decodeBinaryFrame(data);
+    const frameType = pendingWsFrameTypes.get(requestId);
+    if (frameType !== void 0) {
+      pendingWsFrameTypes.delete(requestId);
+      wsRelayMgr.handleFrame(
+        {
+          type: "ws-frame",
+          streamId: requestId,
+          frameType
+        },
+        body
+      );
+      return;
+    }
+    const chunks = requestBodyChunks.get(requestId);
+    if (!chunks) return;
+    if (oversizedRequestIds.has(requestId)) return;
+    const nextSize = (requestBodySizes.get(requestId) ?? 0) + body.byteLength;
+    requestBodySizes.set(requestId, nextSize);
+    if (nextSize > maxBodySizeBytes) {
+      oversizedRequestIds.add(requestId);
+      requestBodyChunks.delete(requestId);
+      return;
+    }
+    chunks.push(body);
+  }
+  function connect() {
+    emitStatus(reconnectAttempts > 0 ? "reconnecting" : "connecting");
+    disconnectedIntentionally = false;
+    ws = new WebSocket2(wsUrl);
+    ws.binaryType = "arraybuffer";
+    ws.on("open", () => {
+      reconnectAttempts = 0;
+      sendMessage({
+        type: "auth",
+        subdomain: opts.subdomain,
+        ttl: opts.ttl,
+        sessionId: sessionId ?? void 0
+      });
+    });
+    ws.on("message", (data) => {
+      if (data instanceof ArrayBuffer) {
+        handleBinaryFrame(data);
+        return;
+      }
+      if (Buffer.isBuffer(data)) {
+        const str = data.toString("utf8");
+        if (!str.startsWith("{")) {
+          const ab = data.buffer.slice(
+            data.byteOffset,
+            data.byteOffset + data.byteLength
+          );
+          handleBinaryFrame(ab);
+          return;
+        }
+        const msg2 = parseTextMessage(str);
+        if (msg2) handleTextMessage(msg2);
+        return;
+      }
+      const raw = typeof data === "string" ? data : String(data);
+      const msg = parseTextMessage(raw);
+      if (msg) handleTextMessage(msg);
+    });
+    ws.on("close", () => {
+      if (disconnectedIntentionally) return;
+      scheduleReconnect();
+    });
+    ws.on("error", (err) => {
+      emitter.emit("error", err);
+    });
+  }
+  function handleTextMessage(msg) {
+    switch (msg.type) {
+      case "auth-ack": {
+        sessionId = msg.sessionId;
+        maxBodySizeBytes = msg.maxBodySizeBytes;
+        const displayTtl = msg.remainingTtl > 0 ? msg.remainingTtl : msg.ttl;
+        emitStatus("connected");
+        emitter.emit("authenticated", {
+          url: msg.url,
+          ttl: displayTtl,
+          sessionId: msg.sessionId,
+          maxBodySizeBytes: msg.maxBodySizeBytes
+        });
+        break;
+      }
+      case "http-request": {
+        const contentLength = parseContentLength(
+          headerValue(msg.headers, "content-length")
+        );
+        if (contentLength !== null && contentLength > maxBodySizeBytes) {
+          respondWith413(
+            msg.id,
+            `Request body exceeds ${maxBodySizeBytes} byte limit`
+          );
+          break;
+        }
+        if (msg.hasBody) {
+          requestBodyChunks.set(msg.id, []);
+          requestBodySizes.set(msg.id, 0);
+          pendingRequestMeta.set(msg.id, msg);
+        } else {
+          handleHttpRequest(msg, null);
+        }
+        break;
+      }
+      case "http-request-end": {
+        const chunks = requestBodyChunks.get(msg.id);
+        requestBodyChunks.delete(msg.id);
+        const reqMeta = pendingRequestMeta.get(msg.id);
+        pendingRequestMeta.delete(msg.id);
+        requestBodySizes.delete(msg.id);
+        if (!reqMeta) break;
+        if (oversizedRequestIds.delete(msg.id)) {
+          respondWith413(
+            msg.id,
+            `Request body exceeds ${maxBodySizeBytes} byte limit`
+          );
+          break;
+        }
+        const body = concatChunks(chunks ?? []);
+        handleHttpRequest(reqMeta, body.byteLength > 0 ? body : null);
+        break;
+      }
+      case "http-body-chunk": {
+        break;
+      }
+      case "ping": {
+        sendMessage({ type: "pong" });
+        break;
+      }
+      case "ws-upgrade": {
+        wsRelayMgr.handleUpgrade(ws, msg, sendMessage);
+        break;
+      }
+      case "ws-frame": {
+        pendingWsFrameTypes.set(msg.streamId, msg.frameType);
+        break;
+      }
+      case "ws-close": {
+        wsRelayMgr.handleClose(msg);
+        break;
+      }
+      case "error": {
+        if (msg.message === "Tunnel TTL expired") {
+          emitStatus("expired");
+          emitter.emit("expired");
+        } else {
+          emitter.emit("error", new Error(msg.message));
+        }
+        break;
+      }
+    }
+  }
+  async function handleHttpRequest(msg, body) {
+    const startTime = Date.now();
+    const localUrl = `http://${opts.host}:${opts.port}${msg.path}`;
+    try {
+      const reqHeaders = new Headers();
+      for (const [key, value] of Object.entries(msg.headers)) {
+        const lower = key.toLowerCase();
+        if (lower === "host" || lower === "connection" || lower === "transfer-encoding")
+          continue;
+        reqHeaders.set(key, value);
+      }
+      const response = await fetch(localUrl, {
+        method: msg.method,
+        headers: reqHeaders,
+        body: body ? toArrayBuffer(body) : void 0,
+        redirect: "manual"
+      });
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const contentLength = parseContentLength(
+        headerValue(responseHeaders, "content-length")
+      );
+      if (contentLength !== null && contentLength > maxBodySizeBytes) {
+        respondWith413(
+          msg.id,
+          `Response body exceeds ${maxBodySizeBytes} byte limit`
+        );
+        emitter.emit("traffic", {
+          id: msg.id,
+          method: msg.method,
+          path: msg.path,
+          status: 413,
+          duration: Date.now() - startTime,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        return;
+      }
+      const bufferedResponse = await readBodyWithinLimit(response.body);
+      if (!bufferedResponse) {
+        respondWith413(
+          msg.id,
+          `Response body exceeds ${maxBodySizeBytes} byte limit`
+        );
+        emitter.emit("traffic", {
+          id: msg.id,
+          method: msg.method,
+          path: msg.path,
+          status: 413,
+          duration: Date.now() - startTime,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        return;
+      }
+      const hasBody = bufferedResponse.totalBytes > 0;
+      sendMessage({
+        type: "http-response-meta",
+        id: msg.id,
+        status: response.status,
+        headers: responseHeaders,
+        hasBody
+      });
+      if (hasBody) {
+        const chunkSize = 64 * 1024;
+        for (const chunk of bufferedResponse.chunks) {
+          for (let offset = 0; offset < chunk.byteLength; offset += chunkSize) {
+            const end = Math.min(offset + chunkSize, chunk.byteLength);
+            const piece = chunk.slice(offset, end);
+            sendMessage({
+              type: "http-body-chunk",
+              id: msg.id,
+              done: false
+            });
+            ws?.send(encodeBinaryFrame(msg.id, piece));
+          }
+        }
+      }
+      sendMessage({
+        type: "http-response-end",
+        id: msg.id
+      });
+      emitter.emit("traffic", {
+        id: msg.id,
+        method: msg.method,
+        path: msg.path,
+        status: response.status,
+        duration: Date.now() - startTime,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      const errMessage = err.message;
+      const isConnectionRefused = errMessage.includes("ECONNREFUSED") || errMessage.includes("fetch failed");
+      sendMessage({
+        type: "error",
+        message: isConnectionRefused ? `Could not connect to localhost:${opts.port} \u2014 is your server running?` : `Failed to reach localhost:${opts.port}: ${errMessage}`,
+        requestId: msg.id,
+        status: 502
+      });
+      emitter.emit("traffic", {
+        id: msg.id,
+        method: msg.method,
+        path: msg.path,
+        status: 502,
+        duration: Date.now() - startTime,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  function concatChunks(chunks) {
+    const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  }
+  function scheduleReconnect() {
+    if (reconnectAttempts >= PROTOCOL.BACKOFF_MAX_ATTEMPTS) {
+      emitStatus("disconnected");
+      return;
+    }
+    emitStatus("reconnecting");
+    const baseDelay = PROTOCOL.BACKOFF_BASE_MS * Math.pow(PROTOCOL.BACKOFF_MULTIPLIER, reconnectAttempts);
+    const delay = Math.min(baseDelay, PROTOCOL.BACKOFF_MAX_MS);
+    const jitter = delay * (PROTOCOL.BACKOFF_JITTER_MIN + Math.random() * (PROTOCOL.BACKOFF_JITTER_MAX - PROTOCOL.BACKOFF_JITTER_MIN));
+    reconnectAttempts++;
+    setTimeout(() => connect(), delay + jitter);
+  }
+  function disconnect() {
+    disconnectedIntentionally = true;
+    emitStatus("disconnected");
+    wsRelayMgr.closeAll();
+    ws?.close(1e3, "Client disconnect");
+    ws = null;
+  }
+  return {
+    connect,
+    disconnect,
+    on: emitter.on.bind(emitter)
+  };
+}
+
+// src/index.ts
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+
+// ../../packages/tunnel-core/dist/index.js
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function printError(message) {
+  console.log(`  ${import_picocolors.default.red("Error:")} ${message}`);
+}
+var execFileAsync = promisify(execFile);
+function isValidPort(value) {
+  return Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+function parseTurboDryRunOutput(output) {
+  const start = output.indexOf("{");
+  const end = output.lastIndexOf("}");
+  if (start < 0 || end < start) {
+    throw new Error("Could not find JSON payload in Turborepo dry-run output");
+  }
+  const rawJson = output.slice(start, end + 1);
+  const parsed = JSON.parse(rawJson);
+  if (!Array.isArray(parsed.tasks)) {
+    throw new Error(
+      "Unexpected Turborepo dry-run format (missing tasks array)"
+    );
+  }
+  return parsed.tasks;
+}
+function collectRegexPorts(command, pattern) {
+  const ports = [];
+  let match = null;
+  while ((match = pattern.exec(command)) !== null) {
+    const port = Number.parseInt(match[1], 10);
+    if (isValidPort(port)) {
+      ports.push(port);
+    }
+  }
+  return ports;
+}
+function extractExplicitPorts(command) {
+  const patterns = [
+    /(?:^|\s)PORT=(\d{2,5})(?=\s|$)/g,
+    /--port(?:=|\s+)(\d{2,5})(?=\s|$)/g,
+    /(?:^|\s)-p\s+(\d{2,5})(?=\s|$)/g,
+    /(?:^|\s)-p(\d{2,5})(?=\s|$)/g,
+    /--listen(?:=|\s+)(?:[^\s:]+:)?(\d{2,5})(?=\s|$)/g,
+    /https?:\/\/[^\s/:]+:(\d{2,5})(?=[/\s]|$)/g
+  ];
+  const discovered = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    for (const port of collectRegexPorts(command, pattern)) {
+      discovered.add(port);
+    }
+  }
+  return [...discovered];
+}
+function inferDefaultPort(command) {
+  const normalized = command.toLowerCase();
+  if (/\bwrangler\s+dev\b/.test(normalized)) return 8787;
+  if (/\bnext\s+dev\b/.test(normalized)) return 3e3;
+  if (/\bnuxt\s+dev\b/.test(normalized)) return 3e3;
+  if (/\bremix\s+dev\b/.test(normalized)) return 3e3;
+  if (/\bastro\s+dev\b/.test(normalized)) return 4321;
+  if (/\bstart-storybook\b/.test(normalized)) return 6006;
+  if (/\bstorybook\b.*\bdev\b/.test(normalized)) return 6006;
+  if (/\bvite(?:\s|$)/.test(normalized) && !/\bvitest\b/.test(normalized)) {
+    return 5173;
+  }
+  return null;
+}
+async function discoverTurboPorts(options) {
+  const args = ["turbo", "run", options.task, "--dry=json"];
+  const filter = options.filter?.trim();
+  if (filter) {
+    args.push(`--filter=${filter}`);
+  }
+  let combinedOutput = "";
+  try {
+    const { stdout, stderr } = await execFileAsync("bunx", args, {
+      cwd: options.cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    combinedOutput = `${stdout}
+${stderr}`;
+  } catch (err) {
+    const error = err;
+    const extra = [error.stdout, error.stderr].filter(Boolean).join("\n");
+    throw new Error(
+      `Failed to run \`bunx ${args.join(" ")}\`${extra ? `
+${extra}` : ""}`
+    );
+  }
+  const tasks = parseTurboDryRunOutput(combinedOutput);
+  const discovered = [];
+  for (const task of tasks) {
+    const command = task.command?.trim();
+    if (!command) continue;
+    const explicitPorts = extractExplicitPorts(command);
+    if (explicitPorts.length > 0) {
+      for (const port of explicitPorts) {
+        discovered.push({
+          port,
+          packageName: task.package ?? "unknown",
+          directory: task.directory ?? "unknown",
+          command,
+          reason: "explicit"
+        });
+      }
+      continue;
+    }
+    const defaultPort = inferDefaultPort(command);
+    if (defaultPort !== null) {
+      discovered.push({
+        port: defaultPort,
+        packageName: task.package ?? "unknown",
+        directory: task.directory ?? "unknown",
+        command,
+        reason: "default"
+      });
+    }
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const entry of discovered) {
+    if (!deduped.has(entry.port)) {
+      deduped.set(entry.port, entry);
+    }
+  }
+  return [...deduped.values()].sort((a, b) => a.port - b.port);
+}
+function normalizeDomain(raw) {
+  return raw.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/\.$/, "");
+}
+var SESSION_FILE_NAME = "session.json";
+var configDirOverride;
+function getConfigDir(create) {
+  const dir = configDirOverride ?? join(homedir(), ".config", "xpose");
+  if (create) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getSessionPath(create) {
+  return join(getConfigDir(create), SESSION_FILE_NAME);
+}
+function saveSession(session) {
+  const path = getSessionPath(true);
+  writeFileSync(path, JSON.stringify(session, null, 2), "utf-8");
+}
+function loadSession() {
+  const path = getSessionPath(false);
+  let data;
+  try {
+    data = readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+  let session;
+  try {
+    session = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!session.createdAt || !Array.isArray(session.tunnels)) {
+    return null;
+  }
+  const elapsed = Date.now() - new Date(session.createdAt).getTime();
+  const windowMs = PROTOCOL.SESSION_RESUME_WINDOW_SECONDS * 1e3;
+  if (elapsed > windowMs) {
+    return null;
+  }
+  return session;
+}
+
+// src/index.ts
+import React2 from "react";
+import { render } from "ink";
+
+// src/tui/app.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import Spinner from "ink-spinner";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MAX_TRAFFIC_ENTRIES = 100;
+var MIN_SPLIT_WIDTH = 80;
+function formatTtl(seconds) {
+  if (seconds < 0) seconds = 0;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  return `${h}h ${m}m ${s}s`;
+}
+function formatTime(date) {
+  const hh = String(date.getHours()).padStart(2, "0");
+  const mm = String(date.getMinutes()).padStart(2, "0");
+  const ss = String(date.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function openBrowser(url) {
+  const { exec } = __require("child_process");
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+  exec(cmd);
+}
+function TunnelCard({
+  tunnel,
+  showPortPrefix
+}) {
+  const portLabel = showPortPrefix ? ` :${tunnel.port}` : "";
+  switch (tunnel.status) {
+    case "connected":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "\u2713 " }),
+          /* @__PURE__ */ jsx(Text, { color: "green", children: "Connected" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: portLabel })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2192 " }),
+          /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: tunnel.url })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "Forwarding to localhost:",
+          tunnel.port
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "  ",
+          "TTL:",
+          " ",
+          /* @__PURE__ */ jsx(Text, { color: "yellow", children: formatTtl(tunnel.ttlRemaining) })
+        ] })
+      ] });
+    case "connecting":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+          /* @__PURE__ */ jsx(Text, { color: "yellow", children: " Connecting..." }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: portLabel })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "Port ",
+          tunnel.port
+        ] })
+      ] });
+    case "reconnecting":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+          /* @__PURE__ */ jsx(Text, { color: "yellow", children: " Reconnecting..." }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: portLabel })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "Port ",
+          tunnel.port
+        ] }),
+        tunnel.lastError && /* @__PURE__ */ jsxs(Text, { children: [
+          "  ",
+          /* @__PURE__ */ jsx(Text, { color: "red", children: "Error: " }),
+          /* @__PURE__ */ jsx(Text, { children: tunnel.lastError })
+        ] })
+      ] });
+    case "disconnected":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "\u2717 " }),
+          /* @__PURE__ */ jsx(Text, { color: "red", children: "Disconnected" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: portLabel })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "Port ",
+          tunnel.port
+        ] }),
+        tunnel.lastError && /* @__PURE__ */ jsxs(Text, { children: [
+          "  ",
+          /* @__PURE__ */ jsx(Text, { color: "red", children: "Error: " }),
+          /* @__PURE__ */ jsx(Text, { children: tunnel.lastError })
+        ] })
+      ] });
+    case "expired":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "\u2717 " }),
+          /* @__PURE__ */ jsx(Text, { color: "red", children: "Tunnel expired" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: portLabel })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "Port ",
+          tunnel.port
+        ] })
+      ] });
+  }
+}
+var METHOD_COLORS = {
+  GET: "cyan",
+  HEAD: "cyan",
+  POST: "green",
+  PUT: "yellow",
+  DELETE: "red",
+  PATCH: "magenta",
+  OPTIONS: "gray"
+};
+function statusColor(status) {
+  if (status >= 500) return "red";
+  if (status >= 400) return "yellow";
+  if (status >= 300) return "cyan";
+  if (status >= 200) return "green";
+  return "white";
+}
+function TrafficLine({ entry }) {
+  const method = entry.method.padEnd(7);
+  const path = entry.path.length > 30 ? entry.path.slice(0, 30) : entry.path.padEnd(30);
+  const duration = `${String(entry.duration).padStart(5)}ms`;
+  const time = formatTime(entry.timestamp);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    "  ",
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: time }),
+    "  ",
+    /* @__PURE__ */ jsx(Text, { color: METHOD_COLORS[entry.method] ?? "white", children: method }),
+    "  ",
+    /* @__PURE__ */ jsx(Text, { children: path }),
+    "  ",
+    /* @__PURE__ */ jsx(Text, { color: statusColor(entry.status), children: entry.status }),
+    "  ",
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: duration })
+  ] });
+}
+function Panel({
+  title,
+  focused,
+  width,
+  height,
+  children
+}) {
+  const borderColor = focused ? "#3b82f6" : "gray";
+  const titleColor = focused ? "#3b82f6" : "gray";
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      borderStyle: "round",
+      borderColor,
+      children: [
+        /* @__PURE__ */ jsx(Box, { position: "absolute", marginLeft: 1, marginTop: -1, children: /* @__PURE__ */ jsxs(Text, { color: titleColor, bold: focused, children: [
+          " ",
+          title,
+          " "
+        ] }) }),
+        children
+      ]
+    }
+  );
+}
+function App({ clients, ports, onQuit }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [columns, setColumns] = useState(stdout.columns || 80);
+  const [rows, setRows] = useState(stdout.rows || 24);
+  const [tunnels, setTunnels] = useState(
+    () => ports.map((port) => ({
+      port,
+      status: "connecting",
+      url: "",
+      ttlRemaining: 0,
+      maxBodySizeBytes: 0,
+      lastError: ""
+    }))
+  );
+  const [traffic, setTraffic] = useState(
+    []
+  );
+  const seqRef = React.useRef(0);
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [autoScroll, setAutoScroll] = useState(true);
+  const autoScrollRef = React.useRef(true);
+  const [focusedPanel, setFocusedPanel] = useState("right");
+  const showSplit = columns >= MIN_SPLIT_WIDTH;
+  useEffect(() => {
+    function onResize() {
+      setColumns(stdout.columns);
+      setRows(stdout.rows);
+    }
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setTunnels(
+        (prev) => prev.map(
+          (t) => t.status === "connected" && t.ttlRemaining > 0 ? { ...t, ttlRemaining: t.ttlRemaining - 1 } : t
+        )
+      );
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  useEffect(() => {
+    clients.forEach((client, idx) => {
+      client.on("authenticated", ({ url, ttl, maxBodySizeBytes }) => {
+        setTunnels(
+          (prev) => prev.map(
+            (t, i) => i === idx ? {
+              ...t,
+              status: "connected",
+              url,
+              ttlRemaining: ttl,
+              maxBodySizeBytes,
+              lastError: ""
+            } : t
+          )
+        );
+      });
+      client.on("traffic", (entry) => {
+        const portPrefix = clients.length > 1 ? `[${ports[idx]}] ` : "";
+        const seq = ++seqRef.current;
+        setTraffic((prev) => {
+          const next = [
+            ...prev,
+            { ...entry, path: `${portPrefix}${entry.path}`, seq }
+          ];
+          if (next.length > MAX_TRAFFIC_ENTRIES) {
+            return next.slice(next.length - MAX_TRAFFIC_ENTRIES);
+          }
+          return next;
+        });
+        if (autoScrollRef.current) {
+          setScrollOffset(Number.MAX_SAFE_INTEGER);
+        }
+      });
+      client.on("status", (status) => {
+        setTunnels(
+          (prev) => prev.map((t, i) => i === idx ? { ...t, status } : t)
+        );
+      });
+      client.on("error", (err) => {
+        setTunnels(
+          (prev) => prev.map(
+            (t, i) => i === idx ? { ...t, lastError: err.message } : t
+          )
+        );
+      });
+      client.on("expired", () => {
+        setTunnels(
+          (prev) => prev.map(
+            (t, i) => i === idx ? { ...t, status: "expired" } : t
+          )
+        );
+      });
+    });
+  }, [clients, ports]);
+  useEffect(() => {
+    if (tunnels.length > 0 && tunnels.every((t) => t.status === "expired")) {
+      onQuit();
+      exit();
+    }
+  }, [tunnels, exit, onQuit]);
+  const footerHeight = 1;
+  const availableRows = rows - footerHeight;
+  const trafficViewportHeight = showSplit ? Math.max(1, availableRows - 3) : Math.max(1, availableRows - 7);
+  const isRawModeSupported = process.stdin.isTTY ?? false;
+  useInput(
+    (input, key) => {
+      if (input === "q" || input === "c" && key.ctrl) {
+        onQuit();
+        exit();
+        return;
+      }
+      if (input === "b") {
+        const connected = tunnels.find(
+          (t) => t.status === "connected" && t.url
+        );
+        if (connected) {
+          openBrowser(connected.url);
+        }
+        return;
+      }
+      if (key.tab && showSplit) {
+        setFocusedPanel((prev) => prev === "left" ? "right" : "left");
+        return;
+      }
+      if (!showSplit || focusedPanel === "right") {
+        const maxOff = Math.max(0, traffic.length - trafficViewportHeight);
+        if (key.upArrow && maxOff > 0) {
+          setScrollOffset((prev) => {
+            const current = Math.min(prev, maxOff);
+            return Math.max(0, current - 1);
+          });
+          setAutoScroll(false);
+          autoScrollRef.current = false;
+        }
+        if (key.downArrow) {
+          setScrollOffset((prev) => {
+            const current = Math.min(prev, maxOff);
+            const next = current + 1;
+            if (next >= maxOff) {
+              setAutoScroll(true);
+              autoScrollRef.current = true;
+            }
+            return Math.min(next, maxOff);
+          });
+        }
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+  const maxScroll = Math.max(0, traffic.length - trafficViewportHeight);
+  const clampedOffset = Math.min(scrollOffset, maxScroll);
+  const visibleTraffic = traffic.slice(
+    clampedOffset,
+    clampedOffset + trafficViewportHeight
+  );
+  const scrollPercent = traffic.length <= trafficViewportHeight ? 100 : Math.round(clampedOffset / maxScroll * 100);
+  const footerParts = ["q quit", "b open browser"];
+  if (showSplit) {
+    footerParts.push("tab switch panel");
+  }
+  const canScroll = !showSplit || focusedPanel === "right";
+  if (canScroll && traffic.length > 0) {
+    const scrollLabel = autoScroll ? `\u2191\u2193 scroll ${scrollPercent}%` : `\u2191\u2193 scroll ${scrollPercent}% (paused)`;
+    footerParts.push(scrollLabel);
+  }
+  const footer = `  ${footerParts.join(" | ")}`;
+  if (!showSplit) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexShrink: 0, children: tunnels.map((tunnel, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        i > 0 && /* @__PURE__ */ jsx(Text, { children: "" }),
+        /* @__PURE__ */ jsx(TunnelCard, { tunnel, showPortPrefix: tunnels.length > 1 })
+      ] }, i)) }),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, marginTop: 1, children: traffic.length === 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  ",
+        "Waiting for requests..."
+      ] }) : visibleTraffic.map((entry) => /* @__PURE__ */ jsx(TrafficLine, { entry }, entry.seq)) }),
+      /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: footer }) })
+    ] });
+  }
+  const leftWidth = Math.floor(columns * 0.35);
+  const rightWidth = columns - leftWidth;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [
+    /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(
+        Panel,
+        {
+          title: "Tunnels",
+          focused: focusedPanel === "left",
+          width: leftWidth,
+          height: availableRows,
+          children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingTop: 1, children: tunnels.map((tunnel, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            i > 0 && /* @__PURE__ */ jsx(Text, { children: "" }),
+            /* @__PURE__ */ jsx(
+              TunnelCard,
+              {
+                tunnel,
+                showPortPrefix: tunnels.length > 1
+              }
+            )
+          ] }, i)) })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Panel,
+        {
+          title: "Traffic",
+          focused: focusedPanel === "right",
+          width: rightWidth,
+          height: availableRows,
+          children: /* @__PURE__ */ jsx(
+            Box,
+            {
+              flexDirection: "column",
+              paddingTop: 1,
+              paddingLeft: 1,
+              overflowY: "hidden",
+              children: traffic.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Waiting for requests..." }) : visibleTraffic.map((entry) => /* @__PURE__ */ jsx(TrafficLine, { entry }, entry.seq))
+            }
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: footer }) })
+  ] });
+}
+
+// src/index.ts
+function runTunnels(entries, rawTtl) {
+  const tunnelTtl = Math.min(rawTtl, PROTOCOL.MAX_TTL_SECONDS);
+  saveSession({
+    tunnels: entries,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const clients = entries.map(
+    ({ subdomain, port, domain }) => createTunnelClient({
+      subdomain,
+      port,
+      ttl: tunnelTtl,
+      host: "localhost",
+      domain
+    })
+  );
+  const ports = entries.map((e) => e.port);
+  for (const client of clients) {
+    client.connect();
+  }
+  function shutdown() {
+    saveSession({
+      tunnels: entries,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    for (const client of clients) {
+      client.disconnect();
+    }
+    const minutes = PROTOCOL.SESSION_RESUME_WINDOW_SECONDS / 60;
+    console.error(
+      `
+  Session saved. Resume within ${minutes} minutes with: xpose-dev -r
+`
+    );
+  }
+  const inkApp = render(
+    React2.createElement(App, {
+      clients,
+      ports,
+      onQuit: shutdown
+    })
+  );
+  inkApp.waitUntilExit().then(() => {
+    process.exit(0);
+  });
+}
+var main = defineCommand({
+  meta: {
+    name: "xpose-dev",
+    version: "0.0.1",
+    description: "Expose local servers to the internet via Cloudflare"
+  },
+  args: {
+    port: {
+      type: "positional",
+      description: "Local port to expose (optional when using --from-turbo)",
+      required: false
+    },
+    fromTurbo: {
+      type: "boolean",
+      description: "Auto-detect ports from `turbo run <task> --dry=json`"
+    },
+    turboTask: {
+      type: "string",
+      description: "Turborepo task to inspect when using --from-turbo",
+      default: "dev"
+    },
+    turboFilter: {
+      type: "string",
+      description: "Optional Turborepo filter when using --from-turbo"
+    },
+    turboPath: {
+      type: "string",
+      alias: "path",
+      description: "Path to the Turborepo project root when using --from-turbo"
+    },
+    ttl: {
+      type: "string",
+      description: `Tunnel TTL in seconds (default: ${PROTOCOL.DEFAULT_TTL_SECONDS})`,
+      default: String(PROTOCOL.DEFAULT_TTL_SECONDS)
+    },
+    subdomain: {
+      type: "string",
+      description: "Custom subdomain (default: random)"
+    },
+    domain: {
+      type: "string",
+      description: "Public tunnel domain (default: xpose.dev)",
+      default: PROTOCOL.DEFAULT_PUBLIC_DOMAIN
+    },
+    resume: {
+      type: "boolean",
+      alias: "r",
+      description: "Resume the previous tunnel session"
+    }
+  },
+  async run({ args }) {
+    const ttl = parseInt(args.ttl, 10);
+    if (isNaN(ttl) || ttl < 1) {
+      printError("Invalid TTL. Must be a positive number of seconds.");
+      process.exit(1);
+    }
+    if (args.resume) {
+      const manualRawPorts2 = (args._.length > 0 ? args._ : args.port ? [args.port] : []).map(String);
+      if (manualRawPorts2.length > 0 || args.fromTurbo) {
+        printError("Cannot use --resume with port arguments or --from-turbo.");
+        process.exit(1);
+      }
+      const prev = loadSession();
+      if (!prev) {
+        const minutes = PROTOCOL.SESSION_RESUME_WINDOW_SECONDS / 60;
+        printError(
+          `No session to resume (sessions expire after ${minutes} minutes).`
+        );
+        process.exit(1);
+      }
+      return runTunnels(prev.tunnels, ttl);
+    }
+    const manualRawPorts = (args._.length > 0 ? args._ : args.port ? [args.port] : []).map(String);
+    const parsedManualPorts = manualRawPorts.map(
+      (raw) => Number.parseInt(raw, 10)
+    );
+    const invalidManualPort = parsedManualPorts.find(
+      (port) => Number.isNaN(port) || port < 1 || port > 65535
+    );
+    if (invalidManualPort !== void 0) {
+      printError("Invalid port number. Ports must be between 1 and 65535.");
+      process.exit(1);
+    }
+    const ports = new Set(parsedManualPorts);
+    if (args.fromTurbo) {
+      const turboTask = args.turboTask?.trim() || "dev";
+      const turboCwd = args.turboPath ? resolve(process.cwd(), args.turboPath) : process.cwd();
+      if (!existsSync(turboCwd) || !statSync(turboCwd).isDirectory()) {
+        printError(`Invalid --path. Directory does not exist: ${turboCwd}`);
+        process.exit(1);
+      }
+      try {
+        const discovered = await discoverTurboPorts({
+          cwd: turboCwd,
+          task: turboTask,
+          filter: args.turboFilter
+        });
+        if (discovered.length === 0) {
+          printError(`No ports detected from Turborepo task "${turboTask}".`);
+        } else {
+          console.log(
+            `  Discovered from Turborepo (${turboTask}): ${discovered.map((entry) => `${entry.port} [${entry.packageName}]`).join(", ")}`
+          );
+        }
+        for (const entry of discovered) {
+          ports.add(entry.port);
+        }
+      } catch (err) {
+        printError(`Failed to inspect Turborepo: ${err.message}`);
+        process.exit(1);
+      }
+    }
+    if (ports.size === 0) {
+      printError(
+        "No ports provided. Pass ports directly (e.g. `xpose-dev 3000 8787`) or use --from-turbo."
+      );
+      process.exit(1);
+    }
+    const resolvedPorts = [...ports];
+    const baseSubdomain = args.subdomain?.trim();
+    const tunnelDomain = normalizeDomain(
+      args.domain ?? PROTOCOL.DEFAULT_PUBLIC_DOMAIN
+    );
+    if (!tunnelDomain) {
+      printError("Invalid domain. Pass a hostname like xpose.dev.");
+      process.exit(1);
+    }
+    const entries = resolvedPorts.map((port) => {
+      const subdomain = baseSubdomain ? resolvedPorts.length === 1 ? buildCustomSubdomain(baseSubdomain) : buildCustomSubdomain(`${baseSubdomain}-${port}`) : generateSubdomainId();
+      return { subdomain, port, domain: tunnelDomain };
+    });
+    return runTunnels(entries, ttl);
+  }
+});
+runMain(main);
+//# sourceMappingURL=index.js.map