tensorlake 0.5.5 → 0.5.7

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.4.49";
+    SDK_VERSION = "0.5.7";
     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";
@@ -236,6 +236,9 @@ var init_http = __esm({
         if (options.hostHeader) {
           this.headers["Host"] = options.hostHeader;
         }
+        if (options.sandboxIdHeader) {
+          this.headers["X-Tensorlake-Sandbox-Id"] = options.sandboxIdHeader;
+        }
         if (options.routingHint) {
           this.headers["X-Tensorlake-Route-Hint"] = options.routingHint;
         }
@@ -2947,21 +2950,36 @@ function resolveProxyTarget(proxyUrl, sandboxId) {
     if (host === "localhost" || host === "127.0.0.1") {
       return {
         baseUrl: trimTrailingSlashes(proxyUrl),
-        hostHeader: `${sandboxId}.local`
+        hostHeader: `${sandboxId}.local`,
+        sandboxIdHeader: void 0
       };
     }
     const port = parsed.port ? `:${parsed.port}` : "";
     return {
-      baseUrl: `${parsed.protocol}//${sandboxId}.${host}${port}`,
-      hostHeader: void 0
+      baseUrl: `${parsed.protocol}//${host}${port}`,
+      hostHeader: void 0,
+      sandboxIdHeader: sandboxId
     };
   } catch {
     return {
       baseUrl: `${trimTrailingSlashes(proxyUrl)}/${sandboxId}`,
-      hostHeader: void 0
+      hostHeader: void 0,
+      sandboxIdHeader: void 0
     };
   }
 }
+function resolveSandboxLifecycleUrl(apiUrl) {
+  if (isLocalhost(apiUrl)) return apiUrl;
+  try {
+    const parsed = new URL(apiUrl);
+    if (parsed.hostname.startsWith("api.")) {
+      parsed.hostname = "sandbox." + parsed.hostname.slice(4);
+      return parsed.toString().replace(/\/$/, "");
+    }
+  } catch {
+  }
+  return apiUrl;
+}
 function lifecyclePath(path2, isLocal, namespace) {
   if (isLocal) {
     return `/v1/namespaces/${namespace}/${path2}`;
@@ -3188,7 +3206,7 @@ var init_sandbox = __esm({
         this.sandboxId = options.sandboxId;
         this.lifecycleIdentifier = options.sandboxId;
         const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
-        const { baseUrl, hostHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
+        const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
         this.baseUrl = baseUrl;
         this.wsHeaders = {};
         if (options.apiKey) {
@@ -3203,12 +3221,16 @@ var init_sandbox = __esm({
         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
         });
       }
@@ -3249,8 +3271,8 @@ var init_sandbox = __esm({
       /**
        * Attach to an existing sandbox and return a connected handle.
        *
-       * Verifies the sandbox exists via a server GET call, then returns a handle
-       * in whatever state the sandbox is in. Does **not** auto-resume a suspended
+       * 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.
        */
       static async connect(options) {
@@ -3260,15 +3282,12 @@ var init_sandbox = __esm({
           /* _internal */
           true
         );
-        const info = await client.get(options.sandboxId);
         const sandbox = client.connect(
-          info.sandboxId,
+          options.sandboxId,
           options.proxyUrl,
-          options.routingHint ?? info.routingHint
+          options.routingHint
         );
         sandbox.lifecycleClient = client;
-        sandbox._setLifecycleIdentifier(info.sandboxId);
-        sandbox._setName(info.name ?? null);
         return sandbox;
       }
       // --- Static snapshot management ---
@@ -3292,6 +3311,26 @@ var init_sandbox = __esm({
         );
         await client.deleteSnapshot(snapshotId);
       }
+      /** List all sandboxes. No sandbox handle needed. */
+      static async list(options) {
+        const { SandboxClient: SandboxClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+        const client = new SandboxClient2(
+          options,
+          /* _internal */
+          true
+        );
+        return client.list();
+      }
+      /** List all snapshots in the project. No sandbox handle needed. */
+      static async listSnapshots(options) {
+        const { SandboxClient: SandboxClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+        const client = new SandboxClient2(
+          options,
+          /* _internal */
+          true
+        );
+        return client.listSnapshots();
+      }
       // --- Instance lifecycle methods ---
       requireLifecycleClient(operation) {
         if (!this.lifecycleClient) {
@@ -3301,6 +3340,14 @@ var init_sandbox = __esm({
         }
         return this.lifecycleClient;
       }
+      /** Fetch the current sandbox information from the server on demand. */
+      async info() {
+        const client = this.requireLifecycleClient("info");
+        const info = await client.get(this.lifecycleIdentifier);
+        this._setLifecycleIdentifier(info.sandboxId);
+        this._setName(info.name ?? null);
+        return info;
+      }
       /**
        * Fetch the current sandbox status from the server.
        *
@@ -3408,6 +3455,7 @@ var init_sandbox = __esm({
           "/api/v1/processes/run",
           { json: body }
         );
+        const traceId = sseStream.traceId;
         const stdoutLines = [];
         const stderrLines = [];
         let exitCode = -1;
@@ -3426,11 +3474,10 @@ var init_sandbox = __esm({
             }
           }
         }
-        return {
-          exitCode,
-          stdout: stdoutLines.join("\n"),
-          stderr: stderrLines.join("\n")
-        };
+        return Object.assign(
+          { exitCode, stdout: stdoutLines.join("\n"), stderr: stderrLines.join("\n") },
+          { traceId }
+        );
       }
       // --- Process management ---
       /**
@@ -3460,7 +3507,7 @@ var init_sandbox = __esm({
           "/api/v1/processes",
           { body: payload }
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** List all processes (running and exited) tracked by the sandbox daemon. */
       async listProcesses() {
@@ -3477,7 +3524,7 @@ var init_sandbox = __esm({
           "GET",
           `/api/v1/processes/${pid}`
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** Send SIGKILL to a process. */
       async killProcess(pid) {
@@ -3490,7 +3537,7 @@ var init_sandbox = __esm({
           `/api/v1/processes/${pid}/signal`,
           { body: { signal } }
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       // --- Process I/O ---
       /** Write bytes to a process's stdin. The process must have been started with `stdinMode: StdinMode.PIPE`. */
@@ -3510,7 +3557,7 @@ var init_sandbox = __esm({
           "GET",
           `/api/v1/processes/${pid}/stdout`
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** Return all captured stderr lines produced so far by a process. */
       async getStderr(pid) {
@@ -3518,7 +3565,7 @@ var init_sandbox = __esm({
           "GET",
           `/api/v1/processes/${pid}/stderr`
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** Return all captured stdout+stderr lines produced so far by a process. */
       async getOutput(pid) {
@@ -3526,7 +3573,7 @@ var init_sandbox = __esm({
           "GET",
           `/api/v1/processes/${pid}/output`
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       // --- Streaming (SSE) ---
       /** Stream stdout events from a process until it exits. Yields one `OutputEvent` per line. */
@@ -3600,7 +3647,7 @@ var init_sandbox = __esm({
           "GET",
           `/api/v1/files/list?path=${encodeURIComponent(path2)}`
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       // --- PTY ---
       /** Create an interactive PTY session. Returns a `sessionId` and `token` for WebSocket connection via `connectPty()`. */
@@ -3618,7 +3665,7 @@ var init_sandbox = __esm({
           "/api/v1/pty",
           { body: payload }
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** Create a PTY session and connect to it immediately. Cleans up the session if the WebSocket connection fails. */
       async createPty(options) {
@@ -3672,15 +3719,53 @@ var init_sandbox = __esm({
       }
       /** Connect to a sandbox VNC session for programmatic desktop control. */
       async connectDesktop(options) {
+        const port = options?.port ?? 5901;
+        const connectTimeout = options?.connectTimeout ?? 10;
+        const startMs = Date.now();
+        const deadlineMs = startMs + connectTimeout * 1e3;
+        await this.waitForPortReady(port, deadlineMs);
+        const remainingSecs = Math.max(0.1, (deadlineMs - Date.now()) / 1e3);
         return Desktop.connect({
           baseUrl: this.baseUrl,
           wsHeaders: this.wsHeaders,
-          port: options?.port,
+          port,
           password: options?.password,
           shared: options?.shared,
-          connectTimeout: options?.connectTimeout
+          connectTimeout: remainingSecs
         });
       }
+      /**
+       * Poll the in-sandbox daemon until `127.0.0.1:port` accepts a TCP connection.
+       * Uses `bash`'s `/dev/tcp` builtin via `processes/run` — no extra deps in
+       * the sandbox image. `bash` is present on every image we ship.
+       */
+      async waitForPortReady(port, deadlineMs) {
+        const probeIntervalMs = 250;
+        const probeProcessTimeoutSecs = 2;
+        let lastError;
+        while (Date.now() < deadlineMs) {
+          try {
+            const result = await this.run("/bin/bash", {
+              args: ["-c", `exec 3<>/dev/tcp/127.0.0.1/${port}`],
+              timeout: probeProcessTimeoutSecs
+            });
+            if (result.exitCode === 0) {
+              return;
+            }
+          } catch (error) {
+            lastError = error;
+          }
+          const remainingMs = deadlineMs - Date.now();
+          if (remainingMs <= 0) break;
+          await new Promise(
+            (resolve) => setTimeout(resolve, Math.min(probeIntervalMs, remainingMs))
+          );
+        }
+        const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+        throw new SandboxError(
+          `port ${port} did not become reachable inside sandbox within the connect timeout${detail}`
+        );
+      }
       ptyWsUrl(sessionId, token) {
         let wsBase;
         if (this.baseUrl.startsWith("https://")) {
@@ -3699,15 +3784,15 @@ var init_sandbox = __esm({
           "GET",
           "/api/v1/health"
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
       /** Get sandbox daemon info (version, uptime, process counts). */
-      async info() {
+      async daemonInfo() {
         const raw = await this.http.requestJson(
           "GET",
           "/api/v1/info"
         );
-        return fromSnakeKeys(raw);
+        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
       }
     };
   }
@@ -3800,7 +3885,7 @@ var init_client = __esm({
         this.namespace = options?.namespace ?? NAMESPACE;
         this.local = isLocalhost(this.apiUrl);
         this.http = new HttpClient({
-          baseUrl: this.apiUrl,
+          baseUrl: resolveSandboxLifecycleUrl(this.apiUrl),
           apiKey: this.apiKey,
           organizationId: this.organizationId,
           projectId: this.projectId,
@@ -3868,7 +3953,7 @@ var init_client = __esm({
           "GET",
           this.path(`sandboxes/${sandboxId}`)
         );
-        return fromSnakeKeys(raw, "sandboxId");
+        return Object.assign(fromSnakeKeys(raw, "sandboxId"), { traceId: raw.traceId });
       }
       /** List all sandboxes in the namespace. */
       async list() {
@@ -3899,7 +3984,7 @@ var init_client = __esm({
           this.path(`sandboxes/${sandboxId}`),
           { body }
         );
-        return fromSnakeKeys(raw, "sandboxId");
+        return Object.assign(fromSnakeKeys(raw, "sandboxId"), { traceId: raw.traceId });
       }
       /** Get the current proxy port settings for a sandbox. */
       async getPortAccess(sandboxId) {
@@ -4041,7 +4126,7 @@ var init_client = __esm({
           "GET",
           this.path(`snapshots/${snapshotId}`)
         );
-        return fromSnakeKeys(raw, "snapshotId");
+        return Object.assign(fromSnakeKeys(raw, "snapshotId"), { traceId: raw.traceId });
       }
       /** List all snapshots in the namespace. */
       async listSnapshots() {