tensorlake 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -3182,8 +3182,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;
@@ -3209,6 +3212,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;
@@ -3246,9 +3260,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 ---
@@ -3281,6 +3301,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.
        *
@@ -3289,7 +3335,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.
@@ -3299,7 +3345,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
@@ -3312,10 +3358,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
@@ -3327,7 +3373,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() {
@@ -3340,7 +3387,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 ---
@@ -3421,7 +3468,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) {
@@ -3758,7 +3806,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;
@@ -3796,9 +3844,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) {
@@ -3968,9 +4017,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) {
@@ -4050,9 +4100,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) {
@@ -4107,26 +4158,24 @@ 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);
         }
         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 */) {
             throw new SandboxError(
@@ -4965,7 +5014,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",
@@ -4978,8 +5028,7 @@ 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(
@@ -5023,27 +5072,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 }