tensorlake 0.5.29 → 0.5.30

package/dist/index.cjs

@@ -35,7 +35,7 @@ var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TI
 var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
-    SDK_VERSION = "0.5.29";
+    SDK_VERSION = "0.5.30";
     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";
@@ -2969,6 +2969,14 @@ function resolveProxyTarget(proxyUrl, sandboxId) {
     };
   }
 }
+function sandboxUrlFromIngressEndpoint(ingressEndpoint, sandboxId, port = 9501) {
+  const parsed = new URL(ingressEndpoint);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("ingressEndpoint must be an absolute http(s) URL");
+  }
+  const label = port === 9501 ? sandboxId : `${port}-${sandboxId}`;
+  return `${parsed.protocol}//${label}.${parsed.host}`;
+}
 function resolveSandboxLifecycleUrl(apiUrl) {
   if (isLocalhost(apiUrl)) return apiUrl;
   try {
@@ -3027,7 +3035,7 @@ function sendPtyFrame(socket, frame) {
     socket.send(frame, (error) => error ? reject(error) : resolve());
   });
 }
-var import_ws2, DEFAULT_PROCESS_USER, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
+var import_ws2, DEFAULT_PROCESS_USER, SandboxProxyConnection, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
 var init_sandbox = __esm({
   "src/sandbox.ts"() {
     "use strict";
@@ -3041,6 +3049,98 @@ var init_sandbox = __esm({
     init_url();
     import_ws2 = __toESM(require("ws"), 1);
     DEFAULT_PROCESS_USER = "tl-user";
+    SandboxProxyConnection = class {
+      constructor(sandbox, options) {
+        this.sandbox = sandbox;
+        this.options = options;
+        this.routingHint = options.routingHint;
+        this.http = this.configureProxy(
+          options.proxyUrl ?? SANDBOX_PROXY_URL,
+          options.sandboxId,
+          options.routingHint
+        );
+        this.resolveProxyInfo = options.resolveProxyInfo;
+      }
+      baseUrl = "";
+      wsHeaders = {};
+      http;
+      resolveProxyInfo;
+      resolvePromise = null;
+      routingHint;
+      async ensureResolved() {
+        if (this.resolveProxyInfo == null) {
+          return;
+        }
+        if (this.resolvePromise != null) {
+          return this.resolvePromise;
+        }
+        this.resolvePromise = this.resolveProxyInfo(this.sandbox._getLifecycleIdentifier()).then((info) => {
+          this.resolveProxyInfo = void 0;
+          this.sandbox.traceId = info.traceId;
+          this.sandbox._setLifecycleIdentifier(info.sandboxId);
+          this.sandbox._setName(info.name ?? null);
+          this.routingHint = this.routingHint ?? info.routingHint;
+          const proxyUrl = info.ingressEndpoint ?? this.options.proxyUrl ?? SANDBOX_PROXY_URL;
+          const nextHttp = this.configureProxy(proxyUrl, info.sandboxId, this.routingHint);
+          this.http.close();
+          this.http = nextHttp;
+        }).finally(() => {
+          this.resolvePromise = null;
+        });
+        return this.resolvePromise;
+      }
+      async requestJson(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestJson(method, path2, options);
+      }
+      async requestBytes(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestBytes(method, path2, options);
+      }
+      async requestStream(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestStream(method, path2, options);
+      }
+      async requestResponse(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestResponse(method, path2, options);
+      }
+      close() {
+        this.http.close();
+      }
+      configureProxy(proxyUrl, sandboxId, routingHint) {
+        const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(
+          proxyUrl,
+          sandboxId
+        );
+        this.baseUrl = baseUrl;
+        this.wsHeaders = {};
+        if (this.options.apiKey) {
+          this.wsHeaders.Authorization = `Bearer ${this.options.apiKey}`;
+        }
+        if (this.options.organizationId) {
+          this.wsHeaders["X-Forwarded-Organization-Id"] = this.options.organizationId;
+        }
+        if (this.options.projectId) {
+          this.wsHeaders["X-Forwarded-Project-Id"] = this.options.projectId;
+        }
+        if (hostHeader) {
+          this.wsHeaders.Host = hostHeader;
+        }
+        if (sandboxIdHeader) {
+          this.wsHeaders["X-Tensorlake-Sandbox-Id"] = sandboxIdHeader;
+        }
+        return new HttpClient({
+          baseUrl,
+          apiKey: this.options.apiKey,
+          organizationId: this.options.organizationId,
+          projectId: this.options.projectId,
+          hostHeader,
+          sandboxIdHeader,
+          routingHint
+        });
+      }
+    };
     PTY_OP_DATA = 0;
     PTY_OP_RESIZE = 1;
     PTY_OP_READY = 2;
@@ -3206,9 +3306,8 @@ var init_sandbox = __esm({
     Sandbox = class {
       sandboxId;
       traceId = null;
+      proxy;
       http;
-      baseUrl;
-      wsHeaders;
       ownsSandbox = false;
       lifecycleClient = null;
       lifecycleIdentifier;
@@ -3216,34 +3315,14 @@ var init_sandbox = __esm({
       constructor(options) {
         this.sandboxId = options.sandboxId;
         this.lifecycleIdentifier = options.sandboxId;
-        const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
-        const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
-        this.baseUrl = baseUrl;
-        this.wsHeaders = {};
-        if (options.apiKey) {
-          this.wsHeaders.Authorization = `Bearer ${options.apiKey}`;
-        }
-        if (options.organizationId) {
-          this.wsHeaders["X-Forwarded-Organization-Id"] = options.organizationId;
-        }
-        if (options.projectId) {
-          this.wsHeaders["X-Forwarded-Project-Id"] = options.projectId;
-        }
-        if (hostHeader) {
-          this.wsHeaders.Host = hostHeader;
-        }
-        if (sandboxIdHeader) {
-          this.wsHeaders["X-Tensorlake-Sandbox-Id"] = sandboxIdHeader;
-        }
-        this.http = new HttpClient({
-          baseUrl,
-          apiKey: options.apiKey,
-          organizationId: options.organizationId,
-          projectId: options.projectId,
-          hostHeader,
-          sandboxIdHeader,
-          routingHint: options.routingHint
-        });
+        this.proxy = new SandboxProxyConnection(this, options);
+        this.http = this.proxy;
+      }
+      get baseUrl() {
+        return this.proxy.baseUrl;
+      }
+      get wsHeaders() {
+        return this.proxy.wsHeaders;
       }
       get name() {
         return this.sandboxName;
@@ -3256,6 +3335,10 @@ var init_sandbox = __esm({
       _setLifecycleIdentifier(identifier) {
         this.lifecycleIdentifier = identifier;
       }
+      /** @internal Used by the lazy proxy resolver. */
+      _getLifecycleIdentifier() {
+        return this.lifecycleIdentifier;
+      }
       /** @internal Used by SandboxClient.createAndConnect to set ownership. */
       _setOwner(client) {
         this.ownsSandbox = true;
@@ -3282,9 +3365,9 @@ var init_sandbox = __esm({
       /**
        * Attach to an existing sandbox and return a connected handle.
        *
-       * Returns immediately without contacting the server. Call `sandbox.info()`
-       * to fetch the current state on demand. Does **not** auto-resume a suspended
-       * sandbox — call `sandbox.resume()` explicitly.
+       * When `proxyUrl` is omitted, resolves the sandbox first so the handle uses
+       * the correct cloud/region ingress endpoint. Does **not** auto-resume a
+       * suspended sandbox — call `sandbox.resume()` explicitly.
        */
       static async connect(options) {
         const { SandboxClient: SandboxClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
@@ -3698,6 +3781,7 @@ var init_sandbox = __esm({
       }
       /** Attach to an existing PTY session by ID and token and return a connected `Pty` handle. */
       async connectPty(sessionId, token, options) {
+        await this.proxy.ensureResolved();
         const wsUrl = new URL(this.ptyWsUrl(sessionId, token));
         const authToken = wsUrl.searchParams.get("token") ?? token;
         const pty = new Pty({
@@ -3723,6 +3807,7 @@ var init_sandbox = __esm({
       }
       /** Open a TCP tunnel to a port inside the sandbox and return the local listener. */
       async createTunnel(remotePort, options) {
+        await this.proxy.ensureResolved();
         return TcpTunnel.listen({
           baseUrl: this.baseUrl,
           wsHeaders: this.wsHeaders,
@@ -3734,6 +3819,7 @@ var init_sandbox = __esm({
       }
       /** Connect to a sandbox VNC session for programmatic desktop control. */
       async connectDesktop(options) {
+        await this.proxy.ensureResolved();
         const port = options?.port ?? 5901;
         const connectTimeout = options?.connectTimeout ?? 10;
         const startMs = Date.now();
@@ -4053,6 +4139,7 @@ var init_client = __esm({
         return {
           allowUnauthenticatedAccess: info.allowUnauthenticatedAccess ?? false,
           exposedPorts: dedupeAndSortPorts(info.exposedPorts ?? []),
+          ingressEndpoint: info.ingressEndpoint,
           sandboxUrl: info.sandboxUrl
         };
       }
@@ -4326,7 +4413,8 @@ var init_client = __esm({
           apiKey: this.apiKey,
           organizationId: this.organizationId,
           projectId: this.projectId,
-          routingHint
+          routingHint,
+          resolveProxyInfo: proxyUrl == null ? async (currentIdentifier) => this.get(currentIdentifier) : void 0
         });
       }
       /**
@@ -4342,8 +4430,12 @@ var init_client = __esm({
         const startupTimeout = options?.startupTimeout ?? 60;
         const result = options?.poolId != null ? await this.claim(options.poolId) : await this.create(options);
         const requestedName = options?.poolId != null ? null : options?.name ?? null;
-        const finishConnect = (routingHint, name) => {
-          const sandbox = this.connect(result.sandboxId, options?.proxyUrl, routingHint);
+        const finishConnect = (routingHint, name, ingressEndpoint) => {
+          const sandbox = this.connect(
+            result.sandboxId,
+            options?.proxyUrl ?? ingressEndpoint,
+            routingHint
+          );
           sandbox._setOwner(this);
           sandbox.traceId = result.traceId;
           sandbox._setLifecycleIdentifier(result.sandboxId);
@@ -4351,7 +4443,7 @@ var init_client = __esm({
           return sandbox;
         };
         if (result.status === "running" /* RUNNING */) {
-          return finishConnect(result.routingHint, result.name);
+          return finishConnect(result.routingHint, result.name, result.ingressEndpoint);
         }
         if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */) {
           throw new SandboxError(
@@ -4365,7 +4457,7 @@ var init_client = __esm({
         while (Date.now() < deadline) {
           const info = await this.get(result.sandboxId);
           if (info.status === "running" /* RUNNING */) {
-            return finishConnect(info.routingHint, info.name);
+            return finishConnect(info.routingHint, info.name, info.ingressEndpoint);
           }
           if (info.status === "suspended" /* SUSPENDED */ || info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(
@@ -4772,7 +4864,8 @@ __export(index_exports, {
   StdinMode: () => StdinMode,
   TcpTunnel: () => TcpTunnel,
   createSandboxImage: () => createSandboxImage,
-  dockerfileContent: () => dockerfileContent
+  dockerfileContent: () => dockerfileContent,
+  sandboxUrlFromIngressEndpoint: () => sandboxUrlFromIngressEndpoint
 });
 module.exports = __toCommonJS(index_exports);
 init_client();
@@ -5165,6 +5258,7 @@ var APIClient = class {
 // src/index.ts
 init_sandbox_image();
 init_image();
+init_url();
 init_errors();
 init_models();
 // Annotate the CommonJS export names for ESM import in node:
@@ -5195,6 +5289,7 @@ init_models();
   StdinMode,
   TcpTunnel,
   createSandboxImage,
-  dockerfileContent
+  dockerfileContent,
+  sandboxUrlFromIngressEndpoint
 });
 //# sourceMappingURL=index.cjs.map