tensorlake 0.5.2 → 0.5.4

package/dist/index.cjs

@@ -3358,13 +3358,13 @@ var init_sandbox = __esm({
       async checkpoint(options) {
         const client = this.requireLifecycleClient("checkpoint");
         if (options?.wait === false) {
-          await client.snapshot(this.lifecycleIdentifier, { contentMode: options.contentMode });
+          await client.snapshot(this.lifecycleIdentifier, { snapshotType: options.checkpointType });
           return void 0;
         }
         return client.snapshotAndWait(this.lifecycleIdentifier, {
           timeout: options?.timeout,
           pollInterval: options?.pollInterval,
-          contentMode: options?.contentMode
+          snapshotType: options?.checkpointType
         });
       }
       /**
@@ -4023,11 +4023,11 @@ var init_client = __esm({
        * status — the snapshot is created asynchronously. Poll `getSnapshot()` until
        * `completed` or `failed`, or use `snapshotAndWait()` to block automatically.
        *
-       * @param options.contentMode - `"filesystem_only"` for cold-boot snapshots (e.g. image builds).
-       *   Omit to use the server default (full VM snapshot).
+       * @param options.snapshotType - `"filesystem"` for cold-boot snapshots (e.g. image builds).
+       *   Omit to use the server default (`filesystem`).
        */
       async snapshot(sandboxId, options) {
-        const requestOptions = options?.contentMode != null ? { body: { snapshot_content_mode: options.contentMode } } : void 0;
+        const requestOptions = options?.snapshotType != null ? { body: { snapshot_type: options.snapshotType } } : void 0;
         const raw = await this.http.requestJson(
           "POST",
           this.path(`sandboxes/${sandboxId}/snapshot`),
@@ -4071,14 +4071,14 @@ var init_client = __esm({
        * @param sandboxId - ID of the running sandbox to snapshot.
        * @param options.timeout - Max seconds to wait (default 300).
        * @param options.pollInterval - Seconds between status polls (default 1).
-       * @param options.contentMode - Content mode passed through to `snapshot()`.
+       * @param options.snapshotType - Snapshot type passed through to `snapshot()`.
        * @throws {SandboxError} If the snapshot fails or `timeout` elapses.
        */
       async snapshotAndWait(sandboxId, options) {
         const timeout = options?.timeout ?? 300;
         const pollInterval = options?.pollInterval ?? 1;
         const result = await this.snapshot(sandboxId, {
-          contentMode: options?.contentMode
+          snapshotType: options?.snapshotType
         });
         const deadline = Date.now() + timeout * 1e3;
         while (Date.now() < deadline) {
@@ -5070,7 +5070,7 @@ async function createSandboxImage(source, options = {}, deps = {}) {
     await executeDockerfilePlan(sandbox, plan, emit, sleep3);
     emit({ type: "status", message: "Creating snapshot..." });
     const snapshot = await client.snapshotAndWait(sandbox.sandboxId, {
-      contentMode: "filesystem_only"
+      snapshotType: "filesystem"
     });
     emit({
       type: "snapshot_created",
@@ -5131,25 +5131,25 @@ async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
       name: { type: "string", short: "n" },
       cpus: { type: "string" },
       memory: { type: "string" },
-      disk: { type: "string" },
+      disk_mb: { 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] [--disk GB] [--public]");
+    throw new Error("Usage: tensorlake-create-sandbox-image <dockerfile_path> [--name NAME] [--cpus N] [--memory MB] [--disk_mb MB] [--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;
+  const diskMb = parsed.values.disk_mb != null ? Number(parsed.values.disk_mb) : 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}`);
+  if (diskMb != null && !Number.isInteger(diskMb)) {
+    throw new Error(`Invalid --disk_mb value: ${parsed.values.disk_mb}`);
   }
   await createSandboxImage(
     dockerfilePath,
@@ -5157,7 +5157,7 @@ async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
       registeredName: parsed.values.name,
       cpus,
       memoryMb,
-      diskMb: diskGb != null ? diskGb * 1024 : void 0,
+      diskMb,
       isPublic: parsed.values.public
     },
     { emit: ndjsonStdoutEmit }