@tensorlakeai/tensorlake 0.5.151 → 0.5.152

package/dist/index.cjs

@@ -49,7 +49,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_cjs_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";
@@ -314,6 +314,11 @@ function createWorkerBinding(runtime) {
         return runtime.handle("NativeRepositoryClient", args);
       }
     },
+    NativeTcpTunnel: class {
+      constructor() {
+        return runtime.handle("NativeTcpTunnel", []);
+      }
+    },
     validateManagedName: (name) => runtime.call(void 0, "validateManagedName", [name])
   };
 }
@@ -493,7 +498,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;
   }
@@ -941,116 +946,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 === import_ws.default.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 !== import_ws.default.OPEN) {
-        localSocket.destroy();
-        return;
-      }
-      websocket.send(chunk, { binary: true }, (error) => {
-        if (error) {
-          localSocket.destroy(error);
-        }
-      });
-    };
-    const onLocalEnd = () => {
-      if (websocket.readyState === import_ws.default.OPEN) {
-        websocket.close();
-      }
-    };
-    const onLocalClose = () => {
-      if (websocket.readyState === import_ws.default.OPEN || websocket.readyState === import_ws.default.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 === import_ws.default.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}`);
@@ -1083,14 +978,15 @@ async function withTimeout(timeoutMs, operation, timeoutMessage) {
     });
   });
 }
-var net, import_ws, DEFAULT_TUNNEL_CONNECT_TIMEOUT_MS, WEBSOCKET_KEEPALIVE_INTERVAL_MS, TunnelByteStream, TcpTunnel;
+var import_ws, DEFAULT_TUNNEL_CONNECT_TIMEOUT_MS, WEBSOCKET_KEEPALIVE_INTERVAL_MS, TunnelByteStream, TcpTunnel;
 var init_tunnel = __esm({
   "src/tunnel.ts"() {
     "use strict";
     init_cjs_shims();
-    net = __toESM(require("net"), 1);
     init_errors();
     import_ws = __toESM(require("ws"), 1);
+    init_native_sandbox();
+    init_native_worker_client();
     DEFAULT_TUNNEL_CONNECT_TIMEOUT_MS = 1e4;
     WEBSOCKET_KEEPALIVE_INTERVAL_MS = 15e3;
     TunnelByteStream = class _TunnelByteStream {
@@ -1220,24 +1116,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";
@@ -1246,69 +1135,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);
+          }
+        })();
       }
     };
   }