svamp-cli 0.1.52 → 0.1.53

package/dist/tunnel-DhVAOdGd.mjs

@@ -0,0 +1,299 @@
+import * as os from 'os';
+import { r as requireSandboxApiEnv } from './commands-ZuFXrcot.mjs';
+import { WebSocket } from 'ws';
+
+class TunnelClient {
+  ws = null;
+  options;
+  env;
+  sandboxId;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 20;
+  destroyed = false;
+  pingInterval = null;
+  requestCount = 0;
+  localWebSockets = /* @__PURE__ */ new Map();
+  // request_id → local WS connection
+  constructor(options) {
+    this.options = {
+      localHost: "localhost",
+      requestTimeout: 3e4,
+      ...options
+    };
+    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);
+      } catch (err) {
+        reject(new Error(`Failed to create WebSocket: ${err.message}`));
+        return;
+      }
+      this.ws.on("open", () => {
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.options.onConnect?.();
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        const raw = typeof data === "string" ? data : data.toString("utf8");
+        this.handleMessage(raw);
+      });
+      this.ws.on("close", () => {
+        this.stopPingInterval();
+        this.cleanupLocalWebSockets();
+        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;
+  }
+  // ── Message handling ────────────────────────────────────────────────
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "ping":
+        this.send({ type: "pong" });
+        break;
+      case "request":
+        this.options.onRequest?.(msg);
+        this.proxyRequest(msg).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;
+    }
+  }
+  async proxyRequest(req) {
+    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 init = {
+      method: req.method,
+      headers: req.headers,
+      signal: controller.signal
+    };
+    if (req.body && !["GET", "HEAD"].includes(req.method.toUpperCase())) {
+      init.body = Buffer.from(req.body, "base64");
+    }
+    try {
+      const res = await fetch(url, init);
+      clearTimeout(timeout);
+      const bodyBuffer = await res.arrayBuffer();
+      const bodyBase64 = bodyBuffer.byteLength > 0 ? Buffer.from(bodyBuffer).toString("base64") : void 0;
+      const headers = {};
+      res.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      this.send({
+        type: "response",
+        id: req.id,
+        status: res.status,
+        headers,
+        body: bodyBase64
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") {
+        this.send({
+          type: "response",
+          id: req.id,
+          status: 504,
+          headers: { "content-type": "text/plain" },
+          body: Buffer.from("Tunnel: request timeout").toString("base64")
+        });
+      } else {
+        this.send({
+          type: "response",
+          id: req.id,
+          status: 502,
+          headers: { "content-type": "text/plain" },
+          body: Buffer.from(`Tunnel: local service error: ${err.message}`).toString("base64")
+        });
+      }
+    }
+  }
+  // ── 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");
+    if (msg.is_text) {
+      localWs.send(buf.toString("utf8"));
+    } else {
+      localWs.send(buf);
+    }
+  }
+  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));
+    }
+  }
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      this.send({ type: "ping" });
+    }, 3e4);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.options.onError?.(new Error(
+        `Tunnel disconnected: max reconnect attempts (${this.maxReconnectAttempts}) 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",