tensorlake 0.4.45 → 0.4.47

package/dist/sandbox-image.d.cts

@@ -1 +1 @@
-export { v as CreateSandboxImageOptions, x as DockerfileBuildPlan, y as DockerfileInstruction, J as SandboxImageSource, V as createSandboxImage, X as defaultRegisteredName, Y as loadDockerfilePlan, Z as loadImagePlan, _ as logicalDockerfileLines, $ as runCreateSandboxImageCli } from './sandbox-image-B5Fa0xqb.cjs';
+export { v as CreateSandboxImageOptions, x as DockerfileBuildPlan, y as DockerfileInstruction, J as SandboxImageSource, V as createSandboxImage, X as defaultRegisteredName, Y as loadDockerfilePlan, Z as loadImagePlan, _ as logicalDockerfileLines, $ as runCreateSandboxImageCli } from './sandbox-image-B130uMYt.cjs';

package/dist/sandbox-image.d.ts

@@ -1 +1 @@
-export { v as CreateSandboxImageOptions, x as DockerfileBuildPlan, y as DockerfileInstruction, J as SandboxImageSource, V as createSandboxImage, X as defaultRegisteredName, Y as loadDockerfilePlan, Z as loadImagePlan, _ as logicalDockerfileLines, $ as runCreateSandboxImageCli } from './sandbox-image-B5Fa0xqb.js';
+export { v as CreateSandboxImageOptions, x as DockerfileBuildPlan, y as DockerfileInstruction, J as SandboxImageSource, V as createSandboxImage, X as defaultRegisteredName, Y as loadDockerfilePlan, Z as loadImagePlan, _ as logicalDockerfileLines, $ as runCreateSandboxImageCli } from './sandbox-image-B130uMYt.js';

package/dist/sandbox-image.js

@@ -138,6 +138,9 @@ var HttpClient = class {
     if (options.hostHeader) {
       this.headers["Host"] = options.hostHeader;
     }
+    if (options.routingHint) {
+      this.headers["X-Tensorlake-Route-Hint"] = options.routingHint;
+    }
   }
   close() {
     this.abortController?.abort();
@@ -172,12 +175,13 @@ var HttpClient = class {
     const buffer = await response.arrayBuffer();
     return new Uint8Array(buffer);
   }
-  /** Make a request and return the raw Response (for SSE streaming). */
+  /** Make a request and return the response body as an SSE stream. */
   async requestStream(method, path2, options) {
     const response = await this.requestResponse(
       method,
       path2,
       {
+        json: options?.json,
         headers: { Accept: "text/event-stream" },
         signal: options?.signal
       }
@@ -3031,7 +3035,8 @@ var Sandbox = class {
       apiKey: options.apiKey,
       organizationId: options.organizationId,
       projectId: options.projectId,
-      hostHeader
+      hostHeader,
+      routingHint: options.routingHint
     });
   }
   /** @internal Used by SandboxClient.createAndConnect to set ownership. */
@@ -3052,37 +3057,45 @@ var Sandbox = class {
     }
   }
   // --- High-level convenience ---
+  /**
+   * Run a command to completion and return its output.
+   *
+   * Uses a single streaming `POST /api/v1/processes/run` request that starts
+   * the process, streams output, and delivers the exit code over one connection.
+   */
   async run(command, options) {
-    const proc = await this.startProcess(command, {
-      args: options?.args,
-      env: options?.env,
-      workingDir: options?.workingDir
-    });
-    const deadline = options?.timeout ? Date.now() + options.timeout * 1e3 : null;
-    let info;
-    while (true) {
-      info = await this.getProcess(proc.pid);
-      if (info.status !== "running" /* RUNNING */) break;
-      if (deadline && Date.now() > deadline) {
-        await this.killProcess(proc.pid);
-        throw new SandboxError(`Command timed out after ${options.timeout}s`);
+    const body = { command };
+    if (options?.args) body.args = options.args;
+    if (options?.env) body.env = options.env;
+    if (options?.workingDir) body.working_dir = options.workingDir;
+    if (options?.timeout != null) body.timeout = options.timeout;
+    const sseStream = await this.http.requestStream(
+      "POST",
+      "/api/v1/processes/run",
+      { json: body }
+    );
+    const stdoutLines = [];
+    const stderrLines = [];
+    let exitCode = -1;
+    for await (const raw of parseSSEStream(sseStream)) {
+      if (typeof raw.line === "string") {
+        if (raw.stream === "stderr") {
+          stderrLines.push(raw.line);
+        } else {
+          stdoutLines.push(raw.line);
+        }
+      } else if ("exit_code" in raw || "signal" in raw) {
+        if (typeof raw.exit_code === "number") {
+          exitCode = raw.exit_code;
+        } else if (typeof raw.signal === "number") {
+          exitCode = -raw.signal;
+        }
       }
-      await sleep2(100);
-    }
-    const stdoutResp = await this.getStdout(proc.pid);
-    const stderrResp = await this.getStderr(proc.pid);
-    let exitCode;
-    if (info.exitCode != null) {
-      exitCode = info.exitCode;
-    } else if (info.signal != null) {
-      exitCode = -info.signal;
-    } else {
-      exitCode = -1;
     }
     return {
       exitCode,
-      stdout: stdoutResp.lines.join("\n"),
-      stderr: stderrResp.lines.join("\n")
+      stdout: stdoutLines.join("\n"),
+      stderr: stderrLines.join("\n")
     };
   }
   // --- Process management ---
@@ -3331,9 +3344,6 @@ var Sandbox = class {
     return fromSnakeKeys(raw);
   }
 };
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // src/client.ts
 var SandboxClient = class _SandboxClient {
@@ -3549,7 +3559,7 @@ var SandboxClient = class _SandboxClient {
           `Snapshot ${result.snapshotId} failed: ${info.error}`
         );
       }
-      await sleep3(pollInterval * 1e3);
+      await sleep2(pollInterval * 1e3);
     }
     throw new SandboxError(
       `Snapshot ${result.snapshotId} did not complete within ${timeout}s`
@@ -3621,14 +3631,15 @@ var SandboxClient = class _SandboxClient {
     );
   }
   // --- Connect ---
-  connect(identifier, proxyUrl) {
+  connect(identifier, proxyUrl, routingHint) {
     const resolvedProxy = proxyUrl ?? resolveProxyUrl(this.apiUrl);
     return new Sandbox({
       sandboxId: identifier,
       proxyUrl: resolvedProxy,
       apiKey: this.apiKey,
       organizationId: this.organizationId,
-      projectId: this.projectId
+      projectId: this.projectId,
+      routingHint
     });
   }
   async createAndConnect(options) {
@@ -3639,6 +3650,11 @@ var SandboxClient = class _SandboxClient {
     } else {
       result = await this.create(options);
     }
+    if (result.status === "running" /* RUNNING */) {
+      const sandbox = this.connect(result.sandboxId, options?.proxyUrl, result.routingHint);
+      sandbox._setOwner(this);
+      return sandbox;
+    }
     const deadline = Date.now() + startupTimeout * 1e3;
     while (Date.now() < deadline) {
       const info = await this.get(result.sandboxId);
@@ -3652,7 +3668,7 @@ var SandboxClient = class _SandboxClient {
           `Sandbox ${result.sandboxId} terminated during startup`
         );
       }
-      await sleep3(500);
+      await sleep2(500);
     }
     try {
       await this.delete(result.sandboxId);
@@ -3663,7 +3679,7 @@ var SandboxClient = class _SandboxClient {
     );
   }
 };
-function sleep3(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var RESERVED_SANDBOX_MANAGEMENT_PORT = 9501;
@@ -4086,7 +4102,7 @@ async function runChecked(sandbox, command, args, env, workingDir) {
   }
   return result;
 }
-async function runStreaming(sandbox, emit, sleep4, command, args = [], env, workingDir) {
+async function runStreaming(sandbox, emit, sleep3, command, args = [], env, workingDir) {
   const proc = await sandbox.startProcess(command, {
     args,
     env,
@@ -4111,13 +4127,13 @@ async function runStreaming(sandbox, emit, sleep4, command, args = [], env, work
       emitOutputLines(emit, "stderr", finalStderr, stderrSeen);
       break;
     }
-    await sleep4(300);
+    await sleep3(300);
   }
   for (let i = 0; i < 10; i++) {
     if (info.exitCode != null || info.signal != null) {
       break;
     }
-    await sleep4(200);
+    await sleep3(200);
     info = await sandbox.getProcess(proc.pid);
   }
   const exitCode = info.exitCode != null ? info.exitCode : info.signal != null ? -info.signal : 0;
@@ -4215,7 +4231,7 @@ async function copyFromContext(sandbox, emit, contextDir, sources, destination,
     await copyLocalPathToSandbox(sandbox, localSource, remoteDestination);
   }
 }
-async function addUrlToSandbox(sandbox, emit, url, destination, workingDir, processEnv, sleep4) {
+async function addUrlToSandbox(sandbox, emit, url, destination, workingDir, processEnv, sleep3) {
   let destinationPath = resolveContainerPath(destination, workingDir);
   const parsedUrl = new URL(url);
   const fileName = path.posix.basename(parsedUrl.pathname.replace(/\/$/, "")) || "downloaded";
@@ -4231,7 +4247,7 @@ async function addUrlToSandbox(sandbox, emit, url, destination, workingDir, proc
   await runStreaming(
     sandbox,
     emit,
-    sleep4,
+    sleep3,
     "sh",
     [
       "-c",
@@ -4241,7 +4257,7 @@ async function addUrlToSandbox(sandbox, emit, url, destination, workingDir, proc
     workingDir
   );
 }
-async function executeDockerfilePlan(sandbox, plan, emit, sleep4) {
+async function executeDockerfilePlan(sandbox, plan, emit, sleep3) {
   const processEnv = { ...BUILD_SANDBOX_PIP_ENV };
   let workingDir = "/";
   for (const instruction of plan.instructions) {
@@ -4251,7 +4267,7 @@ async function executeDockerfilePlan(sandbox, plan, emit, sleep4) {
       await runStreaming(
         sandbox,
         emit,
-        sleep4,
+        sleep3,
         "sh",
         ["-c", value],
         processEnv,
@@ -4308,7 +4324,7 @@ async function executeDockerfilePlan(sandbox, plan, emit, sleep4) {
           destination,
           workingDir,
           processEnv,
-          sleep4
+          sleep3
         );
       } else {
         await copyFromContext(
@@ -4376,7 +4392,7 @@ async function registerImage(context, name, dockerfile, snapshotId, snapshotUri,
 }
 async function createSandboxImage(source, options = {}, deps = {}) {
   const emit = deps.emit ?? defaultEmit;
-  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const context = buildContextFromEnv();
   const clientFactory = deps.createClient ?? createDefaultClient;
   const register = deps.registerImage ?? ((...args) => registerImage(...args));
@@ -4399,7 +4415,7 @@ async function createSandboxImage(source, options = {}, deps = {}) {
       type: "status",
       message: `Materializing image in sandbox ${sandbox.sandboxId}...`
     });
-    await executeDockerfilePlan(sandbox, plan, emit, sleep4);
+    await executeDockerfilePlan(sandbox, plan, emit, sleep3);
     emit({ type: "status", message: "Creating snapshot..." });
     const snapshot = await client.snapshotAndWait(sandbox.sandboxId, {
       contentMode: "filesystem_only"