tensorlake 0.5.0 → 0.5.2

package/dist/sandbox-image.d.cts

@@ -1 +1 @@
-export { y as CreateSandboxImageOptions, A as DockerfileBuildPlan, B as DockerfileInstruction, Q as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-CMJ_FOOV.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 { y as CreateSandboxImageOptions, A as DockerfileBuildPlan, B as DockerfileInstruction, Q as SandboxImageSource, Y as createSandboxImage, _ as defaultRegisteredName, $ as loadDockerfilePlan, a0 as loadImagePlan, a1 as logicalDockerfileLines, a2 as runCreateSandboxImageCli } from './sandbox-image-CMJ_FOOV.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

@@ -3103,8 +3103,11 @@ var init_sandbox = __esm({
       wsHeaders;
       ownsSandbox = false;
       lifecycleClient = null;
+      lifecycleIdentifier;
+      sandboxName = null;
       constructor(options) {
         this.sandboxId = options.sandboxId;
+        this.lifecycleIdentifier = options.sandboxId;
         const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
         const { baseUrl, hostHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
         this.baseUrl = baseUrl;
@@ -3130,6 +3133,17 @@ var init_sandbox = __esm({
           routingHint: options.routingHint
         });
       }
+      get name() {
+        return this.sandboxName;
+      }
+      /** @internal Used by client wiring to keep locally cached name in sync. */
+      _setName(name) {
+        this.sandboxName = name;
+      }
+      /** @internal Used by lifecycle operations to pin to canonical sandbox ID. */
+      _setLifecycleIdentifier(identifier) {
+        this.lifecycleIdentifier = identifier;
+      }
       /** @internal Used by SandboxClient.createAndConnect to set ownership. */
       _setOwner(client) {
         this.ownsSandbox = true;
@@ -3167,9 +3181,15 @@ var init_sandbox = __esm({
           /* _internal */
           true
         );
-        await client.get(options.sandboxId);
-        const sandbox = client.connect(options.sandboxId, options.proxyUrl, options.routingHint);
+        const info = await client.get(options.sandboxId);
+        const sandbox = client.connect(
+          info.sandboxId,
+          options.proxyUrl,
+          options.routingHint ?? info.routingHint
+        );
         sandbox.lifecycleClient = client;
+        sandbox._setLifecycleIdentifier(info.sandboxId);
+        sandbox._setName(info.name ?? null);
         return sandbox;
       }
       // --- Static snapshot management ---
@@ -3202,6 +3222,32 @@ var init_sandbox = __esm({
         }
         return this.lifecycleClient;
       }
+      /**
+       * Fetch the current sandbox status from the server.
+       *
+       * Always hits the network — the value is not cached locally because the
+       * status changes over the sandbox's lifecycle.
+       */
+      async status() {
+        const client = this.requireLifecycleClient("read_status");
+        const info = await client.get(this.lifecycleIdentifier);
+        this._setLifecycleIdentifier(info.sandboxId);
+        this._setName(info.name ?? null);
+        return info.status;
+      }
+      /**
+       * Update this sandbox's properties (name, exposed ports, proxy auth).
+       *
+       * Naming an ephemeral sandbox makes it non-ephemeral and enables
+       * suspend/resume.
+       */
+      async update(options) {
+        const client = this.requireLifecycleClient("update");
+        const info = await client.update(this.lifecycleIdentifier, options);
+        this._setLifecycleIdentifier(info.sandboxId);
+        this._setName(info.name ?? null);
+        return info;
+      }
       /**
        * Suspend this sandbox.
        *
@@ -3210,7 +3256,7 @@ var init_sandbox = __esm({
        */
       async suspend(options) {
         const client = this.requireLifecycleClient("suspend");
-        await client.suspend(this.sandboxId, options);
+        await client.suspend(this.lifecycleIdentifier, options);
       }
       /**
        * Resume this sandbox.
@@ -3220,7 +3266,7 @@ var init_sandbox = __esm({
        */
       async resume(options) {
         const client = this.requireLifecycleClient("resume");
-        await client.resume(this.sandboxId, options);
+        await client.resume(this.lifecycleIdentifier, options);
       }
       /**
        * Create a snapshot of this sandbox's filesystem and wait for it to
@@ -3233,10 +3279,10 @@ var init_sandbox = __esm({
       async checkpoint(options) {
         const client = this.requireLifecycleClient("checkpoint");
         if (options?.wait === false) {
-          await client.snapshot(this.sandboxId, { contentMode: options.contentMode });
+          await client.snapshot(this.lifecycleIdentifier, { contentMode: options.contentMode });
           return void 0;
         }
-        return client.snapshotAndWait(this.sandboxId, {
+        return client.snapshotAndWait(this.lifecycleIdentifier, {
           timeout: options?.timeout,
           pollInterval: options?.pollInterval,
           contentMode: options?.contentMode
@@ -3248,7 +3294,8 @@ var init_sandbox = __esm({
       async listSnapshots() {
         const client = this.requireLifecycleClient("listSnapshots");
         const all = await client.listSnapshots();
-        return all.filter((s) => s.sandboxId === this.sandboxId);
+        const filtered = all.filter((s) => s.sandboxId === this.lifecycleIdentifier);
+        return Object.assign(filtered, { traceId: all.traceId });
       }
       /** Close the HTTP client. The sandbox keeps running. */
       close() {
@@ -3261,7 +3308,7 @@ var init_sandbox = __esm({
         this.lifecycleClient = null;
         this.close();
         if (client) {
-          await client.delete(this.sandboxId);
+          await client.delete(this.lifecycleIdentifier);
         }
       }
       // --- High-level convenience ---
@@ -3342,7 +3389,8 @@ var init_sandbox = __esm({
           "GET",
           "/api/v1/processes"
         );
-        return (raw.processes ?? []).map((p) => fromSnakeKeys(p));
+        const processes = (raw.processes ?? []).map((p) => fromSnakeKeys(p));
+        return Object.assign(processes, { traceId: raw.traceId });
       }
       /** Get current status and metadata for a process by PID. */
       async getProcess(pid) {
@@ -3594,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));
 }
@@ -3679,7 +3759,7 @@ var init_client = __esm({
           resources: {
             cpus: options?.cpus ?? 1,
             memory_mb: options?.memoryMb ?? 1024,
-            ephemeral_disk_mb: options?.ephemeralDiskMb ?? 1024
+            ...options?.diskMb != null ? { disk_mb: options.diskMb } : {}
           }
         };
         if (options?.image != null) body.image = options.image;
@@ -3717,9 +3797,10 @@ var init_client = __esm({
           "GET",
           this.path("sandboxes")
         );
-        return (raw.sandboxes ?? []).map(
+        const sandboxes = (raw.sandboxes ?? []).map(
           (s) => fromSnakeKeys(s, "sandboxId")
         );
+        return Object.assign(sandboxes, { traceId: raw.traceId });
       }
       /** Update sandbox properties such as name, exposed ports, and proxy auth settings. */
       async update(sandboxId, options) {
@@ -3889,9 +3970,10 @@ var init_client = __esm({
           "GET",
           this.path("snapshots")
         );
-        return (raw.snapshots ?? []).map(
+        const snapshots = (raw.snapshots ?? []).map(
           (s) => fromSnakeKeys(s, "snapshotId")
         );
+        return Object.assign(snapshots, { traceId: raw.traceId });
       }
       /** Delete a snapshot by ID. */
       async deleteSnapshot(snapshotId) {
@@ -3971,9 +4053,10 @@ var init_client = __esm({
           "GET",
           this.path("sandbox-pools")
         );
-        return (raw.pools ?? []).map(
+        const pools = (raw.pools ?? []).map(
           (p) => fromSnakeKeys(p, "poolId")
         );
+        return Object.assign(pools, { traceId: raw.traceId });
       }
       /** Replace the configuration of an existing sandbox pool. */
       async updatePool(poolId, options) {
@@ -4028,30 +4111,39 @@ var init_client = __esm({
        */
       async createAndConnect(options) {
         const startupTimeout = options?.startupTimeout ?? 60;
-        let result;
-        if (options?.poolId != null) {
-          result = await this.claim(options.poolId);
-        } else {
-          result = await this.create(options);
-        }
-        if (result.status === "running" /* RUNNING */) {
-          const sandbox = this.connect(result.sandboxId, options?.proxyUrl, result.routingHint);
+        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);
           sandbox._setOwner(this);
           sandbox.traceId = result.traceId;
+          sandbox._setLifecycleIdentifier(result.sandboxId);
+          sandbox._setName(name ?? requestedName);
           return sandbox;
+        };
+        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 */) {
-            const sandbox = this.connect(result.sandboxId, options?.proxyUrl, info.routingHint);
-            sandbox._setOwner(this);
-            sandbox.traceId = result.traceId;
-            return sandbox;
+            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);
@@ -4728,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'."
@@ -4755,8 +4847,11 @@ async function registerImage(context, name, dockerfile, snapshotId, snapshotUri,
       name,
       dockerfile,
       snapshotId,
+      snapshotSandboxId,
       snapshotUri,
-      isPublic
+      snapshotSizeBytes,
+      rootfsDiskBytes,
+      public: isPublic
     })
   });
   if (!response.ok) {
@@ -4786,7 +4881,8 @@ async function createSandboxImage(source, options = {}, deps = {}) {
     sandbox = await client.createAndConnect({
       ...plan.baseImage == null ? {} : { image: plan.baseImage },
       cpus: options.cpus ?? 2,
-      memoryMb: options.memoryMb ?? 4096
+      memoryMb: options.memoryMb ?? 4096,
+      ...options.diskMb != null ? { diskMb: options.diskMb } : {}
     });
     emit({
       type: "status",
@@ -4799,14 +4895,23 @@ async function createSandboxImage(source, options = {}, deps = {}) {
     });
     emit({
       type: "snapshot_created",
-      snapshot_id: snapshot.snapshotId,
-      snapshot_uri: snapshot.snapshotUri ?? null
+      snapshot_id: snapshot.snapshotId
     });
     if (!snapshot.snapshotUri) {
       throw new Error(
         `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}'...`
@@ -4816,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({
@@ -4844,27 +4952,33 @@ async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
       name: { type: "string", short: "n" },
       cpus: { type: "string" },
       memory: { type: "string" },
+      disk: { type: "string" },
       public: { type: "boolean", default: false }
     }
   });
   const dockerfilePath = parsed.positionals[0];
   if (!dockerfilePath) {
-    throw new Error("Usage: tensorlake-create-sandbox-image <dockerfile_path> [--name NAME] [--cpus N] [--memory MB] [--public]");
+    throw new Error("Usage: tensorlake-create-sandbox-image <dockerfile_path> [--name NAME] [--cpus N] [--memory MB] [--disk GB] [--public]");
   }
   const cpus = parsed.values.cpus != null ? Number(parsed.values.cpus) : void 0;
   const memoryMb = parsed.values.memory != null ? Number(parsed.values.memory) : void 0;
+  const diskGb = parsed.values.disk != null ? Number(parsed.values.disk) : void 0;
   if (cpus != null && !Number.isFinite(cpus)) {
     throw new Error(`Invalid --cpus value: ${parsed.values.cpus}`);
   }
   if (memoryMb != null && !Number.isInteger(memoryMb)) {
     throw new Error(`Invalid --memory value: ${parsed.values.memory}`);
   }
+  if (diskGb != null && !Number.isInteger(diskGb)) {
+    throw new Error(`Invalid --disk value: ${parsed.values.disk}`);
+  }
   await createSandboxImage(
     dockerfilePath,
     {
       registeredName: parsed.values.name,
       cpus,
       memoryMb,
+      diskMb: diskGb != null ? diskGb * 1024 : void 0,
       isPublic: parsed.values.public
     },
     { emit: ndjsonStdoutEmit }