akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/server/tunnel/TunnelAgent.ts

@@ -0,0 +1,237 @@
+import {
+  Logger,
+  type TunnelControlFromAgent,
+  type TunnelReadyFrame,
+  tunnelCloseCode,
+  tunnelWireContract,
+} from "akanjs/common";
+import { TunnelDataSocket } from "./TunnelDataSocket";
+
+export interface TunnelAgentOptions {
+  /** The gateway, as `wss://tunnel.akanjs.com` — scheme included, no path, no trailing slash. */
+  gatewayUrl: string;
+  token: string;
+  hostnames: string[];
+  /** The local app, as `http://localhost:8282`. */
+  origin: string;
+  /** Where a `tcp` stream dials. Local by construction: an agent is a door into one machine, not a router. */
+  tcpHost?: string;
+  name?: string;
+  /** Attempts on a link that has never gone ready before the agent gives up (default 10). */
+  retryLimit?: number;
+  onReady?: (ready: TunnelReadyFrame) => void;
+  /** The control socket dropped and a reconnect is scheduled; the share is down until `onReady` comes again. */
+  onLost?: (reason: string) => void;
+  /** The gateway refused this agent for good. Nothing is retried after one of these. */
+  onFatal?: (error: Error) => void;
+}
+
+/** A refusal the gateway will repeat: retrying a revoked token forever is worse than saying so once. */
+const fatalCloseCodes = new Set<number>([
+  tunnelCloseCode.unauthorized,
+  tunnelCloseCode.unsupportedVersion,
+  tunnelCloseCode.hostnameNotGranted,
+  tunnelCloseCode.superseded,
+]);
+
+const backoffMs = [1_000, 2_000, 4_000, 8_000, 15_000];
+
+const coldAttemptLimit = 10;
+
+/** Dials out to the gateway, so its machine needs no public address, no inbound port and no NAT traversal. */
+export class TunnelAgent {
+  readonly #options: TunnelAgentOptions;
+  readonly logger = new Logger("TunnelAgent");
+  readonly #sockets = new Set<TunnelDataSocket>();
+  #ws: WebSocket | null = null;
+  #ready: TunnelReadyFrame | null = null;
+  #heartbeat: ReturnType<typeof setInterval> | null = null;
+  #retry: ReturnType<typeof setTimeout> | null = null;
+  #attempts = 0;
+  #lastInboundAt = 0;
+  #everReady = false;
+  #stopped = false;
+
+  constructor(options: TunnelAgentOptions) {
+    this.#options = options;
+  }
+
+  get ready() {
+    return this.#ready;
+  }
+
+  /** Resolves with the gateway's own view of the share — the hostnames and URLs it will actually serve. */
+  start(): Promise<TunnelReadyFrame> {
+    return new Promise<TunnelReadyFrame>((resolve, reject) => {
+      const onReady = (ready: TunnelReadyFrame) => {
+        this.#options.onReady?.(ready);
+        resolve(ready);
+      };
+      const onFatal = (error: Error) => {
+        this.#options.onFatal?.(error);
+        reject(error);
+      };
+      this.#connect(onReady, onFatal);
+    });
+  }
+
+  async stop(reason = "client stopped") {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    this.#stopHeartbeat();
+    if (this.#retry) clearTimeout(this.#retry);
+    this.#retry = null;
+    this.#say({ type: "bye", reason });
+    for (const socket of this.#sockets) socket.close();
+    this.#sockets.clear();
+    this.#ws?.close();
+    this.#ws = null;
+    this.#ready = null;
+  }
+
+  #connect(onReady: (ready: TunnelReadyFrame) => void, onFatal: (error: Error) => void) {
+    if (this.#stopped) return;
+    const { gatewayUrl, token, hostnames, name } = this.#options;
+    const ws = new WebSocket(`${gatewayUrl}${tunnelWireContract.controlPath}`, {
+      headers: { authorization: `${tunnelWireContract.authScheme} ${token}` },
+    } as unknown as string[]);
+    this.#ws = ws;
+    ws.onopen = () => {
+      this.#lastInboundAt = Date.now();
+      this.#say({
+        type: "hello",
+        version: tunnelWireContract.version,
+        hostnames,
+        agent: { name: name ?? "akan", version: Bun.version, platform: process.platform },
+      });
+    };
+    ws.onmessage = (event) => {
+      this.#lastInboundAt = Date.now();
+      this.#receive(event.data, onReady);
+    };
+    ws.onerror = () => this.logger.verbose(`Tunnel control socket error`);
+    ws.onclose = (event) => this.#dropped(event.code, event.reason, onReady, onFatal);
+  }
+
+  #receive(data: unknown, onReady: (ready: TunnelReadyFrame) => void) {
+    if (typeof data !== "string") return;
+    const frame = tunnelWireContract.parseFrame(data);
+    if (!frame) return;
+    switch (frame.type) {
+      case "ready":
+        this.#ready = frame;
+        this.#everReady = true;
+        
+        this.#attempts = 0;
+        this.#startHeartbeat(frame.heartbeatMs || tunnelWireContract.defaultHeartbeatMs);
+        this.#grow();
+        this.logger.info(`Tunnel ready: ${frame.urls.join(", ")}`);
+        onReady(frame);
+        return;
+      case "demand":
+        if (this.#ready) this.#ready = { ...this.#ready, idle: frame.idle };
+        this.#grow();
+        return;
+      case "ping":
+        this.#say({ type: "pong", at: frame.at });
+        return;
+      case "pong":
+        return;
+      case "bye":
+        this.logger.info(`Tunnel closed by the gateway${frame.reason ? `: ${frame.reason}` : ""}`);
+        void this.stop(frame.reason ?? "gateway closed");
+        return;
+      default:
+        this.logger.warn(`Tunnel control socket received an unexpected frame: ${frame.type}`);
+    }
+  }
+
+  #dropped(code: number, reason: string, onReady: (ready: TunnelReadyFrame) => void, onFatal: (error: Error) => void) {
+    this.#stopHeartbeat();
+    this.#ws = null;
+    this.#ready = null;
+    
+    for (const socket of this.#sockets) socket.close();
+    this.#sockets.clear();
+    if (this.#stopped) return;
+    if (fatalCloseCodes.has(code)) {
+      this.#stopped = true;
+      onFatal(new Error(`Tunnel refused by the gateway (${code}${reason ? `: ${reason}` : ""})`));
+      return;
+    }
+    const limit = this.#options.retryLimit ?? coldAttemptLimit;
+    if (!this.#everReady && this.#attempts >= limit) {
+      this.#stopped = true;
+      onFatal(
+        new Error(
+          `Tunnel never connected after ${limit} attempts (last close ${code}${reason ? `: ${reason}` : ""}). ` +
+            `Check the token and the gateway url.`,
+        ),
+      );
+      return;
+    }
+    const wait = backoffMs[Math.min(this.#attempts, backoffMs.length - 1)] ?? 15_000;
+    this.#attempts += 1;
+    this.#options.onLost?.(reason || `closed with ${code}`);
+    this.logger.warn(`Tunnel disconnected (${code}), reconnecting in ${wait}ms`);
+    this.#retry = setTimeout(() => {
+      this.#retry = null;
+      this.#connect(onReady, onFatal);
+    }, wait);
+  }
+
+  #startHeartbeat(intervalMs: number) {
+    this.#stopHeartbeat();
+    this.#lastInboundAt = Date.now();
+    this.#heartbeat = setInterval(() => {
+      const ws = this.#ws;
+      if (ws?.readyState !== WebSocket.OPEN) return;
+      
+      if (Date.now() - this.#lastInboundAt > intervalMs * 3) {
+        this.logger.warn(`Tunnel control socket is silent, reconnecting`);
+        ws.close();
+        return;
+      }
+      this.#say({ type: "ping", at: Date.now() });
+    }, intervalMs);
+    this.#heartbeat.unref?.();
+  }
+
+  #stopHeartbeat() {
+    if (this.#heartbeat) clearInterval(this.#heartbeat);
+    this.#heartbeat = null;
+  }
+
+  #say(frame: TunnelControlFromAgent) {
+    if (this.#ws?.readyState !== WebSocket.OPEN) return;
+    this.#ws.send(JSON.stringify(frame));
+  }
+
+  #grow() {
+    const ready = this.#ready;
+    if (!ready || this.#stopped) return;
+    const idle = [...this.#sockets].filter((socket) => !socket.busy).length;
+    const room = Math.min(ready.idle - idle, ready.maxSockets - this.#sockets.size);
+    for (let opened = 0; opened < room; opened += 1) this.#open(ready.sessionId);
+  }
+
+  #open(sessionId: string) {
+    const { gatewayUrl, token, origin, tcpHost = "127.0.0.1" } = this.#options;
+    const socket = new TunnelDataSocket({
+      gatewayUrl,
+      token,
+      sessionId,
+      origin,
+      tcpHost,
+      logger: this.logger,
+      onIdle: () => this.#grow(),
+      onBusy: () => this.#grow(),
+      onGone: (gone) => {
+        this.#sockets.delete(gone);
+        this.#grow();
+      },
+    });
+    this.#sockets.add(socket);
+    socket.open();
+  }
+}

package/server/tunnel/TunnelDataSocket.ts

@@ -0,0 +1,146 @@
+import { type Logger, sleep, type TunnelDataFromAgent, type TunnelOpenFrame, tunnelWireContract } from "akanjs/common";
+import { TunnelHttpStream } from "./TunnelHttpStream";
+import { TunnelTcpStream } from "./TunnelTcpStream";
+import { TunnelWebsocketStream } from "./TunnelWebsocketStream";
+import { type TunnelStream, type TunnelStreamLink, wsBytes } from "./tunnelStream";
+
+export interface TunnelDataSocketOptions {
+  gatewayUrl: string;
+  token: string;
+  sessionId: string;
+  /** Where an `http` or `websocket` stream is replayed, as an http(s) URL with no trailing slash. */
+  origin: string;
+  /** Where a `tcp` stream dials; the port comes from the open frame. */
+  tcpHost: string;
+  logger: Logger;
+  onIdle: (socket: TunnelDataSocket) => void;
+  onBusy: (socket: TunnelDataSocket) => void;
+  onGone: (socket: TunnelDataSocket) => void;
+}
+
+const highWaterMark = tunnelWireContract.chunkBytes * 8;
+
+/** Carries one stream at a time, which is what lets a payload frame be bare bytes with no stream id. */
+export class TunnelDataSocket {
+  readonly #options: TunnelDataSocketOptions;
+  #ws: WebSocket | null = null;
+  #stream: TunnelStream | null = null;
+  #streamId: string | null = null;
+  #gone: boolean = false;
+
+  constructor(options: TunnelDataSocketOptions) {
+    this.#options = options;
+  }
+
+  get busy() {
+    return this.#stream !== null;
+  }
+
+  open() {
+    const { gatewayUrl, token, sessionId, logger } = this.#options;
+    const ws = new WebSocket(`${gatewayUrl}${tunnelWireContract.dataPath}`, {
+      headers: { authorization: `${tunnelWireContract.authScheme} ${token}` },
+    } as unknown as string[]);
+    ws.binaryType = "arraybuffer";
+    this.#ws = ws;
+    ws.onopen = () => this.#send({ type: "attach", version: tunnelWireContract.version, sessionId });
+    ws.onmessage = (event) => this.#receive(event.data);
+    ws.onerror = () => logger.verbose(`Tunnel data socket error`);
+    ws.onclose = () => this.#drop();
+  }
+
+  close() {
+    this.#gone = true;
+    this.#stream?.reset();
+    this.#stream = null;
+    this.#ws?.close();
+    this.#ws = null;
+  }
+
+  #drop() {
+    if (this.#gone) return;
+    this.#gone = true;
+    this.#stream?.reset();
+    this.#stream = null;
+    this.#ws = null;
+    this.#options.onGone(this);
+  }
+
+  #retire() {
+    if (this.#gone) return;
+    this.#gone = true;
+    this.#stream = null;
+    this.#streamId = null;
+    this.#ws?.close();
+    this.#ws = null;
+    this.#options.onGone(this);
+  }
+
+  #receive(data: unknown) {
+    if (typeof data !== "string") {
+      this.#stream?.push(new Uint8Array(data as ArrayBuffer));
+      return;
+    }
+    const frame = tunnelWireContract.parseFrame(data);
+    if (!frame) {
+      this.#options.logger.warn(`Tunnel data socket received an unparseable frame`);
+      return;
+    }
+    
+    if ("streamId" in frame && this.#streamId && frame.streamId !== this.#streamId) return;
+    switch (frame.type) {
+      case "attached":
+        this.#options.onIdle(this);
+        return;
+      case "open":
+        this.#start(frame);
+        return;
+      case "end":
+        this.#stream?.end();
+        return;
+      case "reset":
+        this.#stream?.reset();
+        this.#stream = null;
+        this.#streamId = null;
+        return;
+      case "release":
+        this.#stream = null;
+        this.#streamId = null;
+        this.#options.onIdle(this);
+        return;
+      default:
+        this.#options.logger.warn(`Tunnel data socket received an unexpected frame: ${frame.type}`);
+    }
+  }
+
+  #start(open: TunnelOpenFrame) {
+    const { origin, tcpHost } = this.#options;
+    const link: TunnelStreamLink = {
+      sendFrame: (frame) => this.#send(frame),
+      sendPayload: (payload) => this.#sendPayload(payload),
+      closeSocket: () => this.#retire(),
+    };
+    this.#streamId = open.streamId;
+    this.#stream =
+      open.kind === "websocket"
+        ? new TunnelWebsocketStream(open, link, origin)
+        : open.kind === "tcp"
+          ? new TunnelTcpStream(open, link, tcpHost)
+          : new TunnelHttpStream(open, link, origin);
+    this.#options.onBusy(this);
+    void this.#stream.run();
+  }
+
+  #send(frame: TunnelDataFromAgent) {
+    if (this.#ws?.readyState !== WebSocket.OPEN) return;
+    this.#ws.send(JSON.stringify(frame));
+  }
+
+  async #sendPayload(payload: Uint8Array) {
+    const ws = this.#ws;
+    if (ws?.readyState !== WebSocket.OPEN) return;
+    ws.send(wsBytes(payload));
+    
+    while (ws.readyState === WebSocket.OPEN && ws.bufferedAmount > highWaterMark) await sleep(1);
+  }
+}

package/server/tunnel/TunnelHttpStream.ts

@@ -0,0 +1,86 @@
+import { type TunnelOpenFrame, tunnelWireContract } from "akanjs/common";
+import { type TunnelStream, type TunnelStreamLink, tunnelResetCodeOf } from "./tunnelStream";
+
+const reframedHeaders = new Set(["content-encoding", "content-length"]);
+
+export class TunnelHttpStream implements TunnelStream {
+  readonly #open: TunnelOpenFrame;
+  readonly #link: TunnelStreamLink;
+  readonly #origin: string;
+  readonly #aborter = new AbortController();
+  #body: ReadableStreamDefaultController<Uint8Array> | null = null;
+  readonly #bodyStream: ReadableStream<Uint8Array> | null;
+
+  constructor(open: TunnelOpenFrame, link: TunnelStreamLink, origin: string) {
+    this.#open = open;
+    this.#link = link;
+    this.#origin = origin;
+    this.#bodyStream = open.body
+      ? new ReadableStream<Uint8Array>({
+          start: (controller) => {
+            this.#body = controller;
+          },
+        })
+      : null;
+  }
+
+  async run() {
+    const { streamId, method = "GET", path = "/", headers = [] } = this.#open;
+    try {
+      const response = await fetch(`${this.#origin}${path}`, {
+        method,
+        headers: tunnelWireContract.headersOf(headers),
+        body: this.#bodyStream,
+        signal: this.#aborter.signal,
+        
+        redirect: "manual",
+        
+        duplex: "half",
+      } as RequestInit);
+      const list = tunnelWireContract
+        .headerList(response.headers)
+        .filter(([name]) => !reframedHeaders.has(name.toLowerCase()));
+      this.#link.sendFrame({
+        type: "head",
+        streamId,
+        status: response.status,
+        statusText: response.statusText,
+        headers: list,
+        body: !!response.body,
+      });
+      if (response.body) {
+        for await (const chunk of response.body) {
+          
+          for (let at = 0; at < chunk.byteLength; at += tunnelWireContract.chunkBytes)
+            await this.#link.sendPayload(chunk.subarray(at, at + tunnelWireContract.chunkBytes));
+        }
+      }
+      this.#link.sendFrame({ type: "end", streamId });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#link.sendFrame({ type: "reset", streamId, code: tunnelResetCodeOf(error), message });
+    }
+  }
+
+  push(data: Uint8Array) {
+    try {
+      this.#body?.enqueue(data);
+    } catch {
+      
+      this.#body = null;
+    }
+  }
+
+  end() {
+    try {
+      this.#body?.close();
+    } catch {
+    }
+    this.#body = null;
+  }
+
+  reset() {
+    this.#body = null;
+    this.#aborter.abort();
+  }
+}

package/server/tunnel/TunnelTcpStream.ts

@@ -0,0 +1,96 @@
+import net from "node:net";
+import { type TunnelOpenFrame, tunnelWireContract } from "akanjs/common";
+import { type TunnelStream, type TunnelStreamLink, tunnelResetCodeOf } from "./tunnelStream";
+
+/** A raw TCP stream to a local port (SSH); provider side only — nothing opens one in wire version 1 yet. */
+export class TunnelTcpStream implements TunnelStream {
+  readonly #open: TunnelOpenFrame;
+  readonly #link: TunnelStreamLink;
+  readonly #hostname: string;
+  #socket: net.Socket | null = null;
+  #forwarding: Promise<void> = Promise.resolve();
+  #closed: boolean = false;
+  #gatewayEnded: boolean = false;
+
+  constructor(open: TunnelOpenFrame, link: TunnelStreamLink, hostname: string) {
+    this.#open = open;
+    this.#link = link;
+    this.#hostname = hostname;
+  }
+
+  async run() {
+    const { streamId, port } = this.#open;
+    if (!port) {
+      this.#link.sendFrame({ type: "reset", streamId, code: "protocol", message: "tcp open carries no port" });
+      this.#link.closeSocket();
+      return;
+    }
+    try {
+      await new Promise<void>((resolve, reject) => {
+        
+        const socket = net.connect({ host: this.#hostname, port, allowHalfOpen: true });
+        this.#socket = socket;
+        socket.on("connect", () =>
+          this.#link.sendFrame({ type: "head", streamId, status: 200, headers: [], body: true }),
+        );
+        socket.on("data", (data: Buffer) => {
+          socket.pause();
+          this.#forwarding = this.#forward(socket, data);
+        });
+        
+        socket.on("end", () =>
+          this.#afterForward(() => {
+            if (!this.#closed) this.#link.sendFrame({ type: "end", streamId });
+          }),
+        );
+        socket.on("error", reject);
+        socket.on("close", () =>
+          this.#afterForward(() => {
+            this.#finish();
+            resolve();
+          }),
+        );
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#link.sendFrame({ type: "reset", streamId, code: tunnelResetCodeOf(error), message });
+      this.#finish();
+    }
+  }
+
+  push(data: Uint8Array) {
+    if (this.#closed || this.#gatewayEnded) return;
+    this.#socket?.write(data);
+  }
+
+  end() {
+    this.#gatewayEnded = true;
+    this.#socket?.end();
+  }
+
+  reset() {
+    this.#finish();
+  }
+
+  async #forward(socket: net.Socket, data: Uint8Array) {
+    try {
+      for (let at = 0; at < data.byteLength; at += tunnelWireContract.chunkBytes)
+        await this.#link.sendPayload(data.subarray(at, at + tunnelWireContract.chunkBytes));
+    } finally {
+      if (!this.#closed) socket.resume();
+    }
+  }
+
+  #afterForward(fn: () => void) {
+    void this.#forwarding.then(fn, fn);
+  }
+
+  #finish() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#socket?.destroy();
+    this.#socket = null;
+    
+    this.#link.closeSocket();
+  }
+}

package/server/tunnel/TunnelWebsocketStream.ts

@@ -0,0 +1,110 @@
+import { type TunnelHeaderList, type TunnelOpenFrame, tunnelWireContract, tunnelWsPayload } from "akanjs/common";
+import { type TunnelStream, type TunnelStreamLink, tunnelResetCodeOf, wsBytes } from "./tunnelStream";
+
+const handshakeHeaders = new Set([
+  "sec-websocket-key",
+  "sec-websocket-version",
+  "sec-websocket-extensions",
+  "sec-websocket-accept",
+  "sec-websocket-protocol",
+]);
+
+export class TunnelWebsocketStream implements TunnelStream {
+  readonly #open: TunnelOpenFrame;
+  readonly #link: TunnelStreamLink;
+  readonly #origin: string;
+  #ws: WebSocket | null = null;
+  #closed: boolean = false;
+  #settle: () => void = () => undefined;
+
+  constructor(open: TunnelOpenFrame, link: TunnelStreamLink, origin: string) {
+    this.#open = open;
+    this.#link = link;
+    this.#origin = origin;
+  }
+
+  async run() {
+    const { streamId, path = "/", headers = [] } = this.#open;
+    const url = `${this.#origin.replace(/^http/, "ws")}${path}`;
+    const protocols = headers.find(([name]) => name.toLowerCase() === "sec-websocket-protocol")?.[1];
+    const dialHeaders: Record<string, string> = {};
+    for (const [name, value] of headers) {
+      if (!handshakeHeaders.has(name.toLowerCase())) dialHeaders[name] = value;
+    }
+    await new Promise<void>((resolve) => {
+      this.#settle = resolve;
+      const ws = new WebSocket(url, {
+        headers: dialHeaders,
+        ...(protocols ? { protocols: protocols.split(",").map((one) => one.trim()) } : {}),
+      } as unknown as string[]);
+      ws.binaryType = "arraybuffer";
+      this.#ws = ws;
+      ws.onopen = () => {
+        const accepted: TunnelHeaderList = ws.protocol ? [["sec-websocket-protocol", ws.protocol]] : [];
+        this.#link.sendFrame({ type: "head", streamId, status: 101, headers: accepted });
+      };
+      ws.onmessage = (event) => void this.#forward(event.data);
+      ws.onerror = (event) => {
+        
+        if (!this.#ws || this.#closed) return;
+        const error = (event as unknown as { error?: unknown }).error;
+        this.#link.sendFrame({ type: "reset", streamId, code: tunnelResetCodeOf(error), message: "origin websocket" });
+        this.#finish();
+      };
+      ws.onclose = (event) => {
+        if (this.#closed) return;
+        const payload = new TextEncoder().encode(JSON.stringify({ code: event.code, reason: event.reason }));
+        void this.#link.sendPayload(tunnelWireContract.encodeWsPayload(tunnelWsPayload.close, payload));
+        this.#link.sendFrame({ type: "end", streamId });
+        this.#finish();
+      };
+    });
+  }
+
+  async #forward(data: unknown) {
+    if (typeof data === "string") {
+      const payload = new TextEncoder().encode(data);
+      await this.#link.sendPayload(tunnelWireContract.encodeWsPayload(tunnelWsPayload.text, payload));
+      return;
+    }
+    const bytes = new Uint8Array(data as ArrayBuffer);
+    await this.#link.sendPayload(tunnelWireContract.encodeWsPayload(tunnelWsPayload.binary, bytes));
+  }
+
+  push(data: Uint8Array) {
+    const decoded = tunnelWireContract.decodeWsPayload(data);
+    const ws = this.#ws;
+    if (!decoded || ws?.readyState !== WebSocket.OPEN) return;
+    if (decoded.kind === tunnelWsPayload.text) {
+      ws.send(new TextDecoder().decode(decoded.data));
+      return;
+    }
+    if (decoded.kind === tunnelWsPayload.binary) {
+      ws.send(wsBytes(decoded.data));
+      return;
+    }
+    const { code, reason } = JSON.parse(new TextDecoder().decode(decoded.data) || "{}") as {
+      code?: number;
+      reason?: string;
+    };
+    
+    ws.close(code && code !== 1005 ? code : undefined, reason);
+  }
+
+  end() {
+    this.#ws?.close();
+  }
+
+  reset() {
+    this.#finish();
+    this.#ws?.close();
+  }
+
+  #finish() {
+    if (this.#closed) return;
+    this.#closed = true;
+    
+    this.#link.closeSocket();
+    this.#settle();
+  }
+}

package/server/tunnel/index.ts

@@ -0,0 +1,6 @@
+export * from "./TunnelAgent";
+export * from "./TunnelDataSocket";
+export * from "./TunnelHttpStream";
+export * from "./TunnelTcpStream";
+export * from "./TunnelWebsocketStream";
+export * from "./tunnelStream";