tensorlake 0.5.1 → 0.5.2

package/dist/sandbox-image.d.cts

@@ -1 +1 @@
-export { z as CreateSandboxImageOptions, B as DockerfileBuildPlan, E as DockerfileInstruction, T as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-CEGsGg4V.cjs';
+export { z as CreateSandboxImageOptions, B as DockerfileBuildPlan, E as DockerfileInstruction, T as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-B0WMhyoM.cjs';

package/dist/sandbox-image.d.ts

@@ -1 +1 @@
-export { z as CreateSandboxImageOptions, B as DockerfileBuildPlan, E as DockerfileInstruction, T as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-CEGsGg4V.js';
+export { z as CreateSandboxImageOptions, B as DockerfileBuildPlan, E as DockerfileInstruction, T as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-B0WMhyoM.js';

package/dist/sandbox-image.js

@@ -3642,6 +3642,38 @@ __export(client_exports, {
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function formatStartupFailureMessage(sandboxId, status, options) {
+  const prefix = status === "terminated" /* TERMINATED */ ? `Sandbox ${sandboxId} terminated during startup` : `Sandbox ${sandboxId} became ${status} during startup`;
+  const detail = formatErrorDetails(options.errorDetails);
+  if (detail) {
+    return `${prefix}: ${detail}`;
+  }
+  if (options.terminationReason) {
+    return `${prefix}: termination reason: ${options.terminationReason}`;
+  }
+  return prefix;
+}
+function formatErrorDetails(errorDetails) {
+  if (errorDetails == null) return void 0;
+  if (typeof errorDetails === "string") {
+    const detail = errorDetails.trim();
+    return detail || void 0;
+  }
+  if (Array.isArray(errorDetails)) {
+    const parts = errorDetails.map((item) => formatErrorDetails(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("; ") : JSON.stringify(errorDetails);
+  }
+  if (typeof errorDetails === "object") {
+    for (const key of ["message", "detail", "error", "reason"]) {
+      const value = errorDetails[key];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+    return JSON.stringify(errorDetails);
+  }
+  return String(errorDetails);
+}
 function normalizeUserPorts(ports) {
   return dedupeAndSortPorts(ports.map(validateUserPort));
 }
@@ -4092,15 +4124,26 @@ var init_client = __esm({
         if (result.status === "running" /* RUNNING */) {
           return finishConnect(result.routingHint, result.name);
         }
+        if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */) {
+          throw new SandboxError(
+            formatStartupFailureMessage(result.sandboxId, result.status, {
+              errorDetails: result.errorDetails,
+              terminationReason: result.terminationReason
+            })
+          );
+        }
         const deadline = Date.now() + startupTimeout * 1e3;
         while (Date.now() < deadline) {
           const info = await this.get(result.sandboxId);
           if (info.status === "running" /* RUNNING */) {
             return finishConnect(info.routingHint, info.name);
           }
-          if (info.status === "terminated" /* TERMINATED */) {
+          if (info.status === "suspended" /* SUSPENDED */ || info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(
-              `Sandbox ${result.sandboxId} terminated during startup`
+              formatStartupFailureMessage(result.sandboxId, info.status, {
+                errorDetails: info.errorDetails,
+                terminationReason: info.terminationReason
+              })
             );
           }
           await sleep2(500);
@@ -4777,7 +4820,7 @@ async function executeDockerfilePlan(sandbox, plan, emit, sleep3) {
     );
   }
 }
-async function registerImage(context, name, dockerfile, snapshotId, snapshotUri, isPublic) {
+async function registerImage(context, name, dockerfile, snapshotId, snapshotSandboxId, snapshotUri, snapshotSizeBytes, rootfsDiskBytes, isPublic) {
   if (!context.organizationId || !context.projectId) {
     throw new Error(
       "Organization ID and Project ID are required. Run 'tl login' and 'tl init'."
@@ -4804,8 +4847,11 @@ async function registerImage(context, name, dockerfile, snapshotId, snapshotUri,
       name,
       dockerfile,
       snapshotId,
+      snapshotSandboxId,
       snapshotUri,
-      isPublic
+      snapshotSizeBytes,
+      rootfsDiskBytes,
+      public: isPublic
     })
   });
   if (!response.ok) {
@@ -4856,6 +4902,16 @@ async function createSandboxImage(source, options = {}, deps = {}) {
         `Snapshot ${snapshot.snapshotId} is missing snapshotUri and cannot be registered as a sandbox image.`
       );
     }
+    if (snapshot.sizeBytes == null) {
+      throw new Error(
+        `Snapshot ${snapshot.snapshotId} is missing sizeBytes and cannot be registered as a sandbox image.`
+      );
+    }
+    if (snapshot.rootfsDiskBytes == null) {
+      throw new Error(
+        `Snapshot ${snapshot.snapshotId} is missing rootfsDiskBytes and cannot be registered as a sandbox image.`
+      );
+    }
     emit({
       type: "status",
       message: `Registering image '${plan.registeredName}'...`
@@ -4865,7 +4921,10 @@ async function createSandboxImage(source, options = {}, deps = {}) {
       plan.registeredName,
       plan.dockerfileText,
       snapshot.snapshotId,
+      snapshot.sandboxId,
       snapshot.snapshotUri,
+      snapshot.sizeBytes,
+      snapshot.rootfsDiskBytes,
       options.isPublic ?? false
     );
     emit({