svamp-cli 0.1.85 → 0.1.87

package/dist/tunnel-BDKdemh0.mjs

@@ -1,383 +0,0 @@
-import * as os from 'os';
-import { requireSandboxApiEnv } from './api-BRbsyqJ4.mjs';
-import { WebSocket } from 'ws';
-
-const PING_INTERVAL_MS = 3e4;
-const PONG_TIMEOUT_MS = 1e4;
-const DEFAULT_MAX_RECONNECT_ATTEMPTS = 20;
-class TunnelClient {
-  ws = null;
-  options;
-  env;
-  sandboxId;
-  reconnectAttempts = 0;
-  maxReconnects;
-  destroyed = false;
-  pingTimer = null;
-  pongTimeoutTimer = null;
-  lastPongAt = 0;
-  requestCount = 0;
-  localWebSockets = /* @__PURE__ */ new Map();
-  // request_id → local WS connection
-  pendingBinaryBody = null;
-  // awaiting binary body frame
-  constructor(options) {
-    this.options = {
-      localHost: "localhost",
-      requestTimeout: 12e4,
-      ...options
-    };
-    this.maxReconnects = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
-    this.env = options.env || requireSandboxApiEnv();
-    this.sandboxId = options.sandboxId || this.env.sandboxId || `local-${os.hostname()}-${process.pid}`;
-  }
-  /** Build the WebSocket URL for the tunnel endpoint. */
-  buildWsUrl() {
-    const baseUrl = this.env.apiUrl.replace(/\/+$/, "");
-    const wsBase = baseUrl.replace(/^http/, "ws");
-    const ns = this.env.namespace || "_tunnel";
-    const params = new URLSearchParams({
-      token: this.env.apiKey,
-      sandbox_id: this.sandboxId
-    });
-    return `${wsBase}/services/${ns}/${this.options.name}/tunnel?${params}`;
-  }
-  /** Connect to the tunnel endpoint. */
-  async connect() {
-    if (this.destroyed) return;
-    const url = this.buildWsUrl();
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(url, {
-          maxPayload: 100 * 1024 * 1024
-          // 100MB for large binary bodies
-        });
-      } catch (err) {
-        reject(new Error(`Failed to create WebSocket: ${err.message}`));
-        return;
-      }
-      this.ws.on("open", () => {
-        this.reconnectAttempts = 0;
-        this.lastPongAt = Date.now();
-        this.startPingInterval();
-        this.options.onConnect?.();
-        resolve();
-      });
-      this.ws.on("message", (data, isBinary) => {
-        if (isBinary) {
-          this.handleBinaryBody(data);
-        } else {
-          const raw = typeof data === "string" ? data : data.toString("utf8");
-          this.handleMessage(raw);
-        }
-      });
-      this.ws.on("close", () => {
-        this.stopPingInterval();
-        this.cleanupLocalWebSockets();
-        this.pendingBinaryBody = null;
-        this.options.onDisconnect?.();
-        if (!this.destroyed) {
-          this.scheduleReconnect();
-        }
-      });
-      this.ws.on("error", (err) => {
-        this.options.onError?.(err);
-        if (this.reconnectAttempts === 0) {
-          reject(err);
-        }
-      });
-    });
-  }
-  /** Disconnect and stop reconnecting. */
-  destroy() {
-    this.destroyed = true;
-    this.stopPingInterval();
-    this.cleanupLocalWebSockets();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  /** Number of HTTP requests proxied. */
-  get totalRequests() {
-    return this.requestCount;
-  }
-  /** Number of active WebSocket connections being proxied. */
-  get activeWebSockets() {
-    return this.localWebSockets.size;
-  }
-  /** Whether the tunnel WebSocket is currently open. */
-  get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-  /** Snapshot of tunnel health for external monitoring. */
-  get status() {
-    return {
-      connected: this.ws?.readyState === WebSocket.OPEN,
-      reconnectAttempts: this.reconnectAttempts,
-      lastPongAt: this.lastPongAt,
-      totalRequests: this.requestCount,
-      activeWebSockets: this.localWebSockets.size
-    };
-  }
-  // ── Message handling ────────────────────────────────────────────────
-  handleMessage(raw) {
-    let msg;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!msg || typeof msg !== "object") return;
-    switch (msg.type) {
-      case "ping":
-        this.send({ type: "pong" });
-        break;
-      case "pong":
-        this.lastPongAt = Date.now();
-        this.clearPongTimeout();
-        break;
-      case "request":
-        this.options.onRequest?.(msg);
-        if (msg.has_body) {
-          this.pendingBinaryBody = msg;
-        } else {
-          this.proxyRequest(msg, Buffer.alloc(0)).catch((err) => {
-            this.options.onError?.(err);
-          });
-        }
-        break;
-      case "ws_open":
-        this.handleWsOpen(msg).catch((err) => {
-          this.options.onError?.(err);
-        });
-        break;
-      case "ws_data":
-        this.handleWsData(msg);
-        break;
-      case "ws_close":
-        this.handleWsClose(msg);
-        break;
-    }
-  }
-  handleBinaryBody(data) {
-    const req = this.pendingBinaryBody;
-    this.pendingBinaryBody = null;
-    if (!req) return;
-    this.proxyRequest(req, data).catch((err) => {
-      this.options.onError?.(err);
-    });
-  }
-  async proxyRequest(req, bodyBuffer) {
-    this.requestCount++;
-    const port = req.port || this.options.ports[0];
-    const url = `http://${this.options.localHost}:${port}${req.path}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.options.requestTimeout);
-    const forwardHeaders = { ...req.headers };
-    delete forwardHeaders["accept-encoding"];
-    delete forwardHeaders["Accept-Encoding"];
-    const init = {
-      method: req.method,
-      headers: forwardHeaders,
-      signal: controller.signal
-    };
-    if (bodyBuffer.byteLength > 0 && !["GET", "HEAD"].includes(req.method.toUpperCase())) {
-      init.body = bodyBuffer;
-    }
-    try {
-      const res = await fetch(url, init);
-      clearTimeout(timeout);
-      const headers = {};
-      res.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      this.send({
-        type: "response",
-        id: req.id,
-        status: res.status,
-        headers,
-        streaming: true
-      });
-      if (res.body) {
-        const reader = res.body.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            this.send({ type: "response_chunk", id: req.id });
-            this.sendBinary(Buffer.from(value));
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-      this.send({ type: "response_end", id: req.id });
-    } catch (err) {
-      clearTimeout(timeout);
-      const status = err.name === "AbortError" ? 504 : 502;
-      const message = err.name === "AbortError" ? "Tunnel: request timeout" : `Tunnel: local service error: ${err.message}`;
-      this.send({
-        type: "response",
-        id: req.id,
-        status,
-        headers: { "content-type": "text/plain" },
-        streaming: true
-      });
-      this.send({ type: "response_chunk", id: req.id });
-      this.sendBinary(Buffer.from(message));
-      this.send({ type: "response_end", id: req.id });
-    }
-  }
-  // ── WebSocket proxying ───────────────────────────────────────────────
-  async handleWsOpen(msg) {
-    const port = msg.port || this.options.ports[0];
-    const localUrl = `ws://${this.options.localHost}:${port}${msg.path}`;
-    try {
-      const localWs = new WebSocket(localUrl, {
-        headers: msg.headers
-      });
-      this.localWebSockets.set(msg.id, localWs);
-      localWs.on("message", (data, isBinary) => {
-        const encoded = typeof data === "string" ? Buffer.from(data).toString("base64") : (data instanceof Buffer ? data : Buffer.from(data)).toString("base64");
-        this.send({
-          type: "ws_data",
-          id: msg.id,
-          data: encoded,
-          is_text: !isBinary
-        });
-      });
-      localWs.on("close", (code) => {
-        this.localWebSockets.delete(msg.id);
-        this.send({ type: "ws_close", id: msg.id, code: code || 1e3 });
-      });
-      localWs.on("error", () => {
-        this.localWebSockets.delete(msg.id);
-        this.send({ type: "ws_close", id: msg.id, code: 1011 });
-      });
-    } catch {
-      this.send({ type: "ws_close", id: msg.id, code: 1011 });
-    }
-  }
-  handleWsData(msg) {
-    const localWs = this.localWebSockets.get(msg.id);
-    if (!localWs || localWs.readyState !== WebSocket.OPEN) return;
-    const buf = Buffer.from(msg.data, "base64");
-    try {
-      if (msg.is_text) {
-        localWs.send(buf.toString("utf8"));
-      } else {
-        localWs.send(buf);
-      }
-    } catch (err) {
-      this.options.onError?.(err);
-    }
-  }
-  handleWsClose(msg) {
-    const localWs = this.localWebSockets.get(msg.id);
-    if (localWs) {
-      this.localWebSockets.delete(msg.id);
-      localWs.close(msg.code || 1e3);
-    }
-  }
-  cleanupLocalWebSockets() {
-    for (const [id, ws] of this.localWebSockets) {
-      ws.close(1001);
-    }
-    this.localWebSockets.clear();
-  }
-  // ── WebSocket helpers ───────────────────────────────────────────────
-  send(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-  sendBinary(data) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(data);
-    }
-  }
-  startPingInterval() {
-    this.stopPingInterval();
-    this.pingTimer = setInterval(() => {
-      this.send({ type: "ping" });
-      this.schedulePongTimeout();
-    }, PING_INTERVAL_MS);
-  }
-  stopPingInterval() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-    this.clearPongTimeout();
-  }
-  schedulePongTimeout() {
-    this.clearPongTimeout();
-    this.pongTimeoutTimer = setTimeout(() => {
-      this.options.onError?.(new Error("Tunnel: pong timeout \u2014 connection stale"));
-      if (this.ws) {
-        this.ws.terminate();
-      }
-    }, PONG_TIMEOUT_MS);
-  }
-  clearPongTimeout() {
-    if (this.pongTimeoutTimer) {
-      clearTimeout(this.pongTimeoutTimer);
-      this.pongTimeoutTimer = null;
-    }
-  }
-  scheduleReconnect() {
-    if (this.maxReconnects > 0 && this.reconnectAttempts >= this.maxReconnects) {
-      this.options.onError?.(new Error(
-        `Tunnel disconnected: max reconnect attempts (${this.maxReconnects}) reached`
-      ));
-      return;
-    }
-    this.reconnectAttempts++;
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
-    setTimeout(() => {
-      if (!this.destroyed) {
-        this.connect().catch((err) => {
-          this.options.onError?.(err);
-        });
-      }
-    }, delay);
-  }
-}
-async function runTunnel(name, ports) {
-  const portList = ports.join(", ");
-  const client = new TunnelClient({
-    name,
-    ports,
-    onConnect: () => {
-      console.log(`Tunnel connected: ${name} \u2192 localhost:[${portList}]`);
-    },
-    onDisconnect: () => {
-      console.log("Tunnel disconnected, reconnecting...");
-    },
-    onRequest: (req) => {
-      console.log(`  ${req.method} :${req.port || ports[0]}${req.path}`);
-    },
-    onError: (err) => {
-      console.error(`Tunnel error: ${err.message}`);
-    }
-  });
-  const cleanup = () => {
-    console.log("\nTunnel shutting down...");
-    client.destroy();
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  try {
-    await client.connect();
-    console.log(`Tunnel is active. Press Ctrl+C to stop.`);
-    await new Promise(() => {
-    });
-  } catch (err) {
-    console.error(`Failed to establish tunnel: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-export { TunnelClient, runTunnel };