@tensorlakeai/tensorlake 0.5.151 → 0.5.152

package/dist/index.d.cts

@@ -1000,15 +1000,12 @@ interface TunnelAddress {
     port: number;
 }
 declare class TcpTunnel {
+    private readonly native;
     readonly remotePort: number;
     readonly localHost: string;
     readonly localPort: number;
-    private readonly baseUrl;
-    private readonly wsHeaders;
-    private readonly server;
-    private readonly connectTimeoutMs;
-    private readonly activeRelays;
     private closePromise;
+    private readonly lifetime;
     private constructor();
     static listen(options: {
         baseUrl: string;
@@ -1020,7 +1017,6 @@ declare class TcpTunnel {
     }): Promise<TcpTunnel>;
     address(): TunnelAddress;
     close(): Promise<void>;
-    private handleConnection;
 }
 
 type PtyDataHandler = (data: Uint8Array) => void;

package/dist/index.d.ts

@@ -1000,15 +1000,12 @@ interface TunnelAddress {
     port: number;
 }
 declare class TcpTunnel {
+    private readonly native;
     readonly remotePort: number;
     readonly localHost: string;
     readonly localPort: number;
-    private readonly baseUrl;
-    private readonly wsHeaders;
-    private readonly server;
-    private readonly connectTimeoutMs;
-    private readonly activeRelays;
     private closePromise;
+    private readonly lifetime;
     private constructor();
     static listen(options: {
         baseUrl: string;
@@ -1020,7 +1017,6 @@ declare class TcpTunnel {
     }): Promise<TcpTunnel>;
     address(): TunnelAddress;
     close(): Promise<void>;
-    private handleConnection;
 }
 
 type PtyDataHandler = (data: Uint8Array) => void;

package/dist/index.js

@@ -46,7 +46,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_esm_shims();
-    SDK_VERSION = "0.5.151";
+    SDK_VERSION = "0.5.152";
     API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
     API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
     NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
@@ -313,6 +313,11 @@ function createWorkerBinding(runtime) {
         return runtime.handle("NativeRepositoryClient", args);
       }
     },
+    NativeTcpTunnel: class {
+      constructor() {
+        return runtime.handle("NativeTcpTunnel", []);
+      }
+    },
     validateManagedName: (name) => runtime.call(void 0, "validateManagedName", [name])
   };
 }
@@ -490,7 +495,7 @@ var init_native_worker_client = __esm({
       }
     };
     runtimeKey = /* @__PURE__ */ Symbol.for(
-      `tensorlake.native.worker.${false ? "source" : "0.5.151"}.v1`
+      `tensorlake.native.worker.${false ? "source" : "0.5.152"}.v1`
     );
     runtimes = globalThis;
   }
@@ -862,7 +867,6 @@ var init_pending_sandbox = __esm({
 });
 
 // src/tunnel.ts
-import * as net from "net";
 import WebSocket from "ws";
 async function openTunnelWebSocket(options) {
   const wsUrl = buildTunnelWsUrl(options.baseUrl, options.remotePort);
@@ -940,116 +944,6 @@ function normalizeWebSocketData(message) {
   }
   return Buffer.from(message);
 }
-async function relaySocket(localSocket, websocket) {
-  return new Promise((resolve2) => {
-    let settled = false;
-    const keepAliveInterval = setInterval(() => {
-      if (websocket.readyState === WebSocket.OPEN) {
-        websocket.ping();
-      }
-    }, WEBSOCKET_KEEPALIVE_INTERVAL_MS);
-    keepAliveInterval.unref?.();
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      clearInterval(keepAliveInterval);
-      cleanup();
-      resolve2();
-    };
-    const cleanup = () => {
-      localSocket.removeListener("data", onLocalData);
-      localSocket.removeListener("end", onLocalEnd);
-      localSocket.removeListener("close", onLocalClose);
-      localSocket.removeListener("error", onLocalError);
-      websocket.removeListener("message", onWsMessage);
-      websocket.removeListener("close", onWsClose);
-      websocket.removeListener("error", onWsError);
-      websocket.removeListener("ping", onWsPing);
-    };
-    const onLocalData = (chunk) => {
-      if (websocket.readyState !== WebSocket.OPEN) {
-        localSocket.destroy();
-        return;
-      }
-      websocket.send(chunk, { binary: true }, (error) => {
-        if (error) {
-          localSocket.destroy(error);
-        }
-      });
-    };
-    const onLocalEnd = () => {
-      if (websocket.readyState === WebSocket.OPEN) {
-        websocket.close();
-      }
-    };
-    const onLocalClose = () => {
-      if (websocket.readyState === WebSocket.OPEN || websocket.readyState === WebSocket.CONNECTING) {
-        websocket.close();
-      }
-      finish();
-    };
-    const onLocalError = () => {
-      websocket.close();
-      finish();
-    };
-    const onWsMessage = (message, isBinary) => {
-      if (!isBinary) {
-        localSocket.destroy(
-          new SandboxError("received unexpected text frame from tunnel")
-        );
-        websocket.close();
-        return;
-      }
-      const payload = normalizeWebSocketData(message);
-      if (!localSocket.destroyed) {
-        localSocket.write(payload);
-      }
-    };
-    const onWsClose = () => {
-      if (!localSocket.destroyed) {
-        localSocket.end();
-      }
-      finish();
-    };
-    const onWsError = (error) => {
-      localSocket.destroy(error);
-      finish();
-    };
-    const onWsPing = (data) => {
-      if (websocket.readyState === WebSocket.OPEN) {
-        websocket.pong(data, false, () => {
-        });
-      }
-    };
-    localSocket.on("data", onLocalData);
-    localSocket.on("end", onLocalEnd);
-    localSocket.on("close", onLocalClose);
-    localSocket.on("error", onLocalError);
-    websocket.on("message", onWsMessage);
-    websocket.on("close", onWsClose);
-    websocket.on("error", onWsError);
-    websocket.on("ping", onWsPing);
-  });
-}
-async function listenServer(server, localPort, localHost) {
-  await new Promise((resolve2, reject) => {
-    const onError = (error) => {
-      server.removeListener("listening", onListening);
-      reject(
-        new SandboxError(
-          `failed to bind local tunnel listener on ${localHost}:${localPort}: ${error.message}`
-        )
-      );
-    };
-    const onListening = () => {
-      server.removeListener("error", onError);
-      resolve2();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen(localPort, localHost);
-  });
-}
 function validatePort(port, label, allowZero = false) {
   if (!Number.isInteger(port)) {
     throw new SandboxError(`${label} must be an integer, got ${port}`);
@@ -1088,6 +982,8 @@ var init_tunnel = __esm({
     "use strict";
     init_esm_shims();
     init_errors();
+    init_native_sandbox();
+    init_native_worker_client();
     DEFAULT_TUNNEL_CONNECT_TIMEOUT_MS = 1e4;
     WEBSOCKET_KEEPALIVE_INTERVAL_MS = 15e3;
     TunnelByteStream = class _TunnelByteStream {
@@ -1217,24 +1113,17 @@ var init_tunnel = __esm({
       }
     };
     TcpTunnel = class _TcpTunnel {
-      remotePort;
-      localHost;
-      localPort;
-      baseUrl;
-      wsHeaders;
-      server;
-      connectTimeoutMs;
-      activeRelays = /* @__PURE__ */ new Set();
-      closePromise = null;
-      constructor(options) {
-        this.baseUrl = options.baseUrl;
-        this.wsHeaders = options.wsHeaders;
-        this.remotePort = options.remotePort;
-        this.localHost = options.localHost;
-        this.localPort = options.localPort;
-        this.server = options.server;
-        this.connectTimeoutMs = options.connectTimeoutMs;
+      constructor(native, remotePort, localHost, localPort) {
+        this.native = native;
+        this.remotePort = remotePort;
+        this.localHost = localHost;
+        this.localPort = localPort;
+        this.lifetime = native.waitClosed();
+        void this.lifetime.catch(() => {
+        });
       }
+      closePromise = null;
+      lifetime;
       static async listen(options) {
         const remotePort = validatePort(options.remotePort, "remote port");
         const localHost = options.localHost ?? "127.0.0.1";
@@ -1243,69 +1132,37 @@ var init_tunnel = __esm({
           "local port",
           true
         );
-        const connectTimeoutMs = secondsToMillis(options.connectTimeout ?? 10);
-        const server = net.createServer();
-        await listenServer(server, localPort, localHost);
-        const address = server.address();
-        if (!address || typeof address === "string") {
-          server.close();
-          throw new SandboxError("failed to determine bound tunnel address");
-        }
-        const tunnel = new _TcpTunnel({
-          baseUrl: options.baseUrl,
-          wsHeaders: options.wsHeaders,
-          remotePort,
-          localHost,
-          localPort: address.port,
-          server,
-          connectTimeoutMs
-        });
-        server.on("connection", (localSocket) => {
-          void tunnel.handleConnection(localSocket);
-        });
-        return tunnel;
+        const timeout = secondsToMillis(options.connectTimeout ?? 10) / 1e3;
+        const native = new (loadNativeSandboxBinding()).NativeTcpTunnel();
+        try {
+          const port = await callNative(
+            () => native.listen(
+              options.baseUrl,
+              options.wsHeaders,
+              remotePort,
+              localHost,
+              localPort,
+              timeout
+            )
+          );
+          return new _TcpTunnel(native, remotePort, localHost, port);
+        } catch (error) {
+          releaseNativeHandle(native);
+          throw error;
+        }
       }
       address() {
         return { host: this.localHost, port: this.localPort };
       }
       async close() {
-        if (this.closePromise) {
-          return this.closePromise;
-        }
-        for (const relay of this.activeRelays) {
-          relay.localSocket.destroy();
-          relay.websocket?.close();
-        }
-        this.closePromise = new Promise((resolve2, reject) => {
-          this.server.close((error) => {
-            if (error) {
-              reject(new SandboxError(`failed to close tunnel listener: ${error.message}`));
-              return;
-            }
-            resolve2();
-          });
-        });
-        return this.closePromise;
-      }
-      async handleConnection(localSocket) {
-        localSocket.setNoDelay(true);
-        const relay = { localSocket, websocket: null };
-        this.activeRelays.add(relay);
-        try {
-          relay.websocket = await openTunnelWebSocket({
-            baseUrl: this.baseUrl,
-            wsHeaders: this.wsHeaders,
-            remotePort: this.remotePort,
-            connectTimeoutMs: this.connectTimeoutMs
-          });
-          await relaySocket(localSocket, relay.websocket);
-        } catch (error) {
-          localSocket.destroy(
-            error instanceof Error ? error : new Error(String(error))
-          );
-        } finally {
-          this.activeRelays.delete(relay);
-        }
+        return this.closePromise ??= (async () => {
+          try {
+            await callNative(() => this.native.close());
+            await this.lifetime;
+          } finally {
+            releaseNativeHandle(this.native);
+          }
+        })();
       }
     };
   }