tensorlake 0.4.39 → 0.4.41

package/dist/index.js

@@ -119,8 +119,8 @@ var HttpClient = class {
     this.abortController = null;
   }
   /** Make a JSON request, returning the parsed response body. */
-  async requestJson(method, path, options) {
-    const response = await this.requestResponse(method, path, {
+  async requestJson(method, path2, options) {
+    const response = await this.requestResponse(method, path2, {
       json: options?.body,
       headers: options?.headers,
       signal: options?.signal
@@ -130,14 +130,14 @@ var HttpClient = class {
     return JSON.parse(text);
   }
   /** Make a request returning raw bytes. */
-  async requestBytes(method, path, options) {
+  async requestBytes(method, path2, options) {
     const headers = { ...options?.headers ?? {} };
     if (options?.contentType) {
       headers["Content-Type"] = options.contentType;
     }
     const response = await this.requestResponse(
       method,
-      path,
+      path2,
       {
         body: options?.body,
         headers,
@@ -148,10 +148,10 @@ var HttpClient = class {
     return new Uint8Array(buffer);
   }
   /** Make a request and return the raw Response (for SSE streaming). */
-  async requestStream(method, path, options) {
+  async requestStream(method, path2, options) {
     const response = await this.requestResponse(
       method,
-      path,
+      path2,
       {
         headers: { Accept: "text/event-stream" },
         signal: options?.signal
@@ -163,7 +163,7 @@ var HttpClient = class {
     return response.body;
   }
   /** Make a request and return the raw Response. */
-  async requestResponse(method, path, options) {
+  async requestResponse(method, path2, options) {
     const headers = {
       ...this.headers,
       ...options?.headers ?? {}
@@ -175,15 +175,15 @@ var HttpClient = class {
     const body = hasJsonBody ? JSON.stringify(options?.json) : normalizeRequestBody(options?.body);
     return this.doFetch(
       method,
-      path,
+      path2,
       body,
       headers,
       options?.signal,
       options?.allowHttpErrors ?? false
     );
   }
-  async doFetch(method, path, body, headers, signal, allowHttpErrors = false) {
-    const url = `${this.baseUrl}${path}`;
+  async doFetch(method, path2, body, headers, signal, allowHttpErrors = false) {
+    const url = `${this.baseUrl}${path2}`;
     let lastError;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       if (attempt > 0) {
@@ -216,7 +216,7 @@ var HttpClient = class {
           return response;
         }
         const errorBody = await response.text().catch(() => "");
-        throwMappedError(response.status, errorBody, path);
+        throwMappedError(response.status, errorBody, path2);
       } catch (err) {
         clearTimeout(timeoutId);
         if (err instanceof RemoteAPIError || err instanceof SandboxNotFoundError || err instanceof PoolNotFoundError || err instanceof PoolInUseError) {
@@ -247,7 +247,7 @@ function normalizeRequestBody(body) {
   }
   return body;
 }
-function throwMappedError(status, body, path) {
+function throwMappedError(status, body, path2) {
   let message = body;
   try {
     const parsed = JSON.parse(body);
@@ -256,19 +256,19 @@ function throwMappedError(status, body, path) {
   } catch {
   }
   if (status === 404) {
-    if (path.includes("sandbox-pools") || path.includes("pools")) {
-      const match = path.match(/sandbox-pools\/([^/]+)/);
+    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
+      const match = path2.match(/sandbox-pools\/([^/]+)/);
       if (match) throw new PoolNotFoundError(match[1]);
     }
-    if (path.includes("sandboxes")) {
-      const match = path.match(/sandboxes\/([^/]+)/);
+    if (path2.includes("sandboxes")) {
+      const match = path2.match(/sandboxes\/([^/]+)/);
       if (match) throw new SandboxNotFoundError(match[1]);
     }
     throw new RemoteAPIError(404, message);
   }
   if (status === 409) {
-    if (path.includes("sandbox-pools") || path.includes("pools")) {
-      const match = path.match(/sandbox-pools\/([^/]+)/);
+    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
+      const match = path2.match(/sandbox-pools\/([^/]+)/);
       if (match) throw new PoolInUseError(match[1], message);
     }
   }
@@ -296,6 +296,7 @@ var SandboxStatus = /* @__PURE__ */ ((SandboxStatus2) => {
   SandboxStatus2["PENDING"] = "pending";
   SandboxStatus2["RUNNING"] = "running";
   SandboxStatus2["SNAPSHOTTING"] = "snapshotting";
+  SandboxStatus2["SUSPENDING"] = "suspending";
   SandboxStatus2["SUSPENDED"] = "suspended";
   SandboxStatus2["TERMINATED"] = "terminated";
   return SandboxStatus2;
@@ -468,18 +469,205 @@ function resolveProxyTarget(proxyUrl, sandboxId) {
     };
   }
 }
-function lifecyclePath(path, isLocal, namespace) {
+function lifecyclePath(path2, isLocal, namespace) {
   if (isLocal) {
-    return `/v1/namespaces/${namespace}/${path}`;
+    return `/v1/namespaces/${namespace}/${path2}`;
   }
-  return `/${path}`;
+  return `/${path2}`;
 }
 
 // src/sandbox.ts
+import WebSocket from "ws";
+var PTY_OP_DATA = 0;
+var PTY_OP_RESIZE = 1;
+var PTY_OP_READY = 2;
+var PTY_OP_EXIT = 3;
+var Pty = class {
+  sessionId;
+  token;
+  wsUrl;
+  wsHeaders;
+  killSession;
+  socket = null;
+  connectPromise = null;
+  intentionalDisconnect = false;
+  exitCode = null;
+  waitSettled = false;
+  dataHandlers = /* @__PURE__ */ new Set();
+  exitHandlers = /* @__PURE__ */ new Set();
+  waitPromise;
+  resolveWait;
+  rejectWait;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.token = options.token;
+    this.wsUrl = options.wsUrl;
+    this.wsHeaders = options.wsHeaders;
+    this.killSession = options.killSession;
+    this.waitPromise = new Promise((resolve, reject) => {
+      this.resolveWait = resolve;
+      this.rejectWait = reject;
+    });
+  }
+  onData(handler) {
+    this.dataHandlers.add(handler);
+    return () => this.dataHandlers.delete(handler);
+  }
+  onExit(handler) {
+    this.exitHandlers.add(handler);
+    if (this.exitCode != null) {
+      queueMicrotask(() => handler(this.exitCode));
+    }
+    return () => this.exitHandlers.delete(handler);
+  }
+  async connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      return this;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.intentionalDisconnect = false;
+    this.connectPromise = new Promise((resolve, reject) => {
+      let opened = false;
+      const socket = new WebSocket(this.wsUrl, {
+        headers: this.wsHeaders
+      });
+      this.socket = socket;
+      socket.on("open", async () => {
+        try {
+          await sendPtyFrame(socket, Buffer.from([PTY_OP_READY]));
+          opened = true;
+          resolve(this);
+        } catch (error) {
+          reject(error);
+        }
+      });
+      socket.on("message", (message) => {
+        const bytes = normalizePtyMessage(message);
+        const opcode = bytes[0];
+        if (opcode === PTY_OP_DATA) {
+          const payload = bytes.subarray(1);
+          for (const handler of this.dataHandlers) {
+            handler(payload);
+          }
+          return;
+        }
+        if (opcode === PTY_OP_EXIT && bytes.length >= 5) {
+          this.finishWait(bytes.readInt32BE(1));
+        }
+      });
+      socket.on("close", (code, reason) => {
+        const closeReason = Buffer.isBuffer(reason) ? reason.toString("utf8") : String(reason);
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        this.connectPromise = null;
+        if (this.exitCode != null) {
+          this.finishWait(this.exitCode);
+          return;
+        }
+        if (closeReason.startsWith("exit:")) {
+          const parsed = Number.parseInt(closeReason.slice(5), 10);
+          this.finishWait(Number.isNaN(parsed) ? -1 : parsed);
+          return;
+        }
+        if (this.intentionalDisconnect) {
+          this.intentionalDisconnect = false;
+          return;
+        }
+        if (!opened) {
+          reject(new SandboxError(
+            `PTY websocket closed before READY completed: ${code} ${closeReason || "no reason"}`
+          ));
+          return;
+        }
+        if (closeReason === "session terminated") {
+          this.failWait(new SandboxError("PTY session terminated"));
+          return;
+        }
+        this.failWait(
+          new SandboxError(
+            `PTY websocket closed unexpectedly: ${code} ${closeReason || "no reason"}`
+          )
+        );
+      });
+      socket.on("error", (error) => {
+        if (!opened) {
+          reject(error);
+        }
+      });
+    });
+    return this.connectPromise;
+  }
+  async sendInput(input) {
+    const socket = this.requireOpenSocket();
+    await sendPtyFrame(socket, encodePtyInput(input));
+  }
+  async resize(cols, rows) {
+    const socket = this.requireOpenSocket();
+    await sendPtyFrame(socket, encodePtyResize(cols, rows));
+  }
+  disconnect(code = 1e3, reason = "client disconnect") {
+    if (!this.socket) return;
+    this.intentionalDisconnect = true;
+    this.socket.close(code, reason);
+  }
+  wait() {
+    return this.waitPromise;
+  }
+  async kill() {
+    await this.killSession();
+  }
+  requireOpenSocket() {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new SandboxError("PTY is not connected");
+    }
+    return this.socket;
+  }
+  finishWait(exitCode) {
+    if (this.waitSettled) return;
+    this.waitSettled = true;
+    this.exitCode = exitCode;
+    for (const handler of this.exitHandlers) {
+      handler(exitCode);
+    }
+    this.resolveWait(exitCode);
+  }
+  failWait(error) {
+    if (this.waitSettled) return;
+    this.waitSettled = true;
+    this.rejectWait(error);
+  }
+};
+function normalizePtyMessage(message) {
+  if (Buffer.isBuffer(message)) return message;
+  if (Array.isArray(message)) {
+    return Buffer.concat(message.map((part) => Buffer.from(part)));
+  }
+  return Buffer.from(message);
+}
+function encodePtyInput(input) {
+  const payload = typeof input === "string" ? Buffer.from(input, "utf8") : Buffer.from(input);
+  return Buffer.concat([Buffer.from([PTY_OP_DATA]), payload]);
+}
+function encodePtyResize(cols, rows) {
+  const frame = Buffer.alloc(5);
+  frame[0] = PTY_OP_RESIZE;
+  frame.writeUInt16BE(cols, 1);
+  frame.writeUInt16BE(rows, 3);
+  return frame;
+}
+function sendPtyFrame(socket, frame) {
+  return new Promise((resolve, reject) => {
+    socket.send(frame, (error) => error ? reject(error) : resolve());
+  });
+}
 var Sandbox = class {
   sandboxId;
   http;
   baseUrl;
+  wsHeaders;
   ownsSandbox = false;
   lifecycleClient = null;
   constructor(options) {
@@ -487,6 +675,19 @@ var Sandbox = class {
     const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
     const { baseUrl, hostHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
     this.baseUrl = baseUrl;
+    this.wsHeaders = {};
+    if (options.apiKey) {
+      this.wsHeaders.Authorization = `Bearer ${options.apiKey}`;
+    }
+    if (options.organizationId) {
+      this.wsHeaders["X-Forwarded-Organization-Id"] = options.organizationId;
+    }
+    if (options.projectId) {
+      this.wsHeaders["X-Forwarded-Project-Id"] = options.projectId;
+    }
+    if (hostHeader) {
+      this.wsHeaders.Host = hostHeader;
+    }
     this.http = new HttpClient({
       baseUrl,
       apiKey: options.apiKey,
@@ -665,29 +866,29 @@ var Sandbox = class {
     }
   }
   // --- File operations ---
-  async readFile(path) {
+  async readFile(path2) {
     return this.http.requestBytes(
       "GET",
-      `/api/v1/files?path=${encodeURIComponent(path)}`
+      `/api/v1/files?path=${encodeURIComponent(path2)}`
     );
   }
-  async writeFile(path, content) {
+  async writeFile(path2, content) {
     await this.http.requestBytes(
       "PUT",
-      `/api/v1/files?path=${encodeURIComponent(path)}`,
+      `/api/v1/files?path=${encodeURIComponent(path2)}`,
       { body: content, contentType: "application/octet-stream" }
     );
   }
-  async deleteFile(path) {
+  async deleteFile(path2) {
     await this.http.requestJson(
       "DELETE",
-      `/api/v1/files?path=${encodeURIComponent(path)}`
+      `/api/v1/files?path=${encodeURIComponent(path2)}`
     );
   }
-  async listDirectory(path) {
+  async listDirectory(path2) {
     const raw = await this.http.requestJson(
       "GET",
-      `/api/v1/files/list?path=${encodeURIComponent(path)}`
+      `/api/v1/files/list?path=${encodeURIComponent(path2)}`
     );
     return fromSnakeKeys(raw);
   }
@@ -708,6 +909,43 @@ var Sandbox = class {
     );
     return fromSnakeKeys(raw);
   }
+  async createPty(options) {
+    const { onData, onExit, ...createOptions } = options;
+    const session = await this.createPtySession(createOptions);
+    try {
+      return await this.connectPty(session.sessionId, session.token, { onData, onExit });
+    } catch (error) {
+      try {
+        await this.http.requestResponse("DELETE", `/api/v1/pty/${session.sessionId}`);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async connectPty(sessionId, token, options) {
+    const wsUrl = new URL(this.ptyWsUrl(sessionId, token));
+    const authToken = wsUrl.searchParams.get("token") ?? token;
+    const pty = new Pty({
+      sessionId,
+      token: authToken,
+      wsUrl: wsUrl.toString(),
+      wsHeaders: {
+        ...this.wsHeaders,
+        "X-PTY-Token": authToken
+      },
+      killSession: async () => {
+        await this.http.requestResponse("DELETE", `/api/v1/pty/${sessionId}`);
+      }
+    });
+    if (options?.onData) {
+      pty.onData(options.onData);
+    }
+    if (options?.onExit) {
+      pty.onExit(options.onExit);
+    }
+    await pty.connect();
+    return pty;
+  }
   ptyWsUrl(sessionId, token) {
     let wsBase;
     if (this.baseUrl.startsWith("https://")) {
@@ -835,6 +1073,15 @@ var SandboxClient = class _SandboxClient {
   async update(sandboxId, options) {
     const body = {};
     if (options.name != null) body.name = options.name;
+    if (options.allowUnauthenticatedAccess != null) {
+      body.allow_unauthenticated_access = options.allowUnauthenticatedAccess;
+    }
+    if (options.exposedPorts != null) {
+      body.exposed_ports = normalizeUserPorts(options.exposedPorts);
+    }
+    if (Object.keys(body).length === 0) {
+      throw new SandboxError("At least one sandbox update field must be provided.");
+    }
     const raw = await this.http.requestJson(
       "PATCH",
       this.path(`sandboxes/${sandboxId}`),
@@ -842,12 +1089,54 @@ var SandboxClient = class _SandboxClient {
     );
     return fromSnakeKeys(raw, "sandboxId");
   }
+  async getPortAccess(sandboxId) {
+    const info = await this.get(sandboxId);
+    return {
+      allowUnauthenticatedAccess: info.allowUnauthenticatedAccess ?? false,
+      exposedPorts: dedupeAndSortPorts(info.exposedPorts ?? []),
+      sandboxUrl: info.sandboxUrl
+    };
+  }
+  async exposePorts(sandboxId, ports, options) {
+    const requestedPorts = normalizeUserPorts(ports);
+    const current = await this.getPortAccess(sandboxId);
+    const desiredPorts = dedupeAndSortPorts([
+      ...current.exposedPorts,
+      ...requestedPorts
+    ]);
+    return this.update(sandboxId, {
+      allowUnauthenticatedAccess: options?.allowUnauthenticatedAccess ?? current.allowUnauthenticatedAccess,
+      exposedPorts: desiredPorts
+    });
+  }
+  async unexposePorts(sandboxId, ports) {
+    const requestedPorts = normalizeUserPorts(ports);
+    const current = await this.getPortAccess(sandboxId);
+    const toRemove = new Set(requestedPorts);
+    const desiredPorts = current.exposedPorts.filter((port) => !toRemove.has(port));
+    return this.update(sandboxId, {
+      allowUnauthenticatedAccess: desiredPorts.length ? current.allowUnauthenticatedAccess : false,
+      exposedPorts: desiredPorts
+    });
+  }
   async delete(sandboxId) {
     await this.http.requestJson(
       "DELETE",
       this.path(`sandboxes/${sandboxId}`)
     );
   }
+  async suspend(sandboxId) {
+    await this.http.requestResponse(
+      "POST",
+      this.path(`sandboxes/${sandboxId}/suspend`)
+    );
+  }
+  async resume(sandboxId) {
+    await this.http.requestResponse(
+      "POST",
+      this.path(`sandboxes/${sandboxId}/resume`)
+    );
+  }
   async claim(poolId) {
     const raw = await this.http.requestJson(
       "POST",
@@ -1015,6 +1304,22 @@ var SandboxClient = class _SandboxClient {
 function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var RESERVED_SANDBOX_MANAGEMENT_PORT = 9501;
+function normalizeUserPorts(ports) {
+  return dedupeAndSortPorts(ports.map(validateUserPort));
+}
+function validateUserPort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new SandboxError(`invalid port '${port}'`);
+  }
+  if (port === RESERVED_SANDBOX_MANAGEMENT_PORT) {
+    throw new SandboxError("port 9501 is reserved for sandbox management");
+  }
+  return port;
+}
+function dedupeAndSortPorts(ports) {
+  return [...new Set(ports)].sort((a, b) => a - b);
+}
 
 // src/cloud-client.ts
 var CloudClient = class _CloudClient {
@@ -1081,19 +1386,19 @@ var CloudClient = class _CloudClient {
     return fromSnakeKeys(raw);
   }
   async runRequest(applicationName, inputs = []) {
-    const path = this.namespacePath(
+    const path2 = this.namespacePath(
       `applications/${encodeURIComponent(applicationName)}`
     );
-    const response = inputs.length === 0 ? await this.http.requestResponse("POST", path, {
+    const response = inputs.length === 0 ? await this.http.requestResponse("POST", path2, {
       body: new Uint8Array(),
       headers: { Accept: "application/json" }
-    }) : inputs.length === 1 && inputs[0].name === "0" ? await this.http.requestResponse("POST", path, {
+    }) : inputs.length === 1 && inputs[0].name === "0" ? await this.http.requestResponse("POST", path2, {
       body: toRequestBody(inputs[0].data),
       headers: {
         Accept: "application/json",
         "Content-Type": inputs[0].contentType
       }
-    }) : await this.runMultipartRequest(path, inputs);
+    }) : await this.runMultipartRequest(path2, inputs);
     const body = await parseJsonResponse(response);
     const requestId = body?.request_id;
     if (!requestId) {
@@ -1247,7 +1552,7 @@ var CloudClient = class _CloudClient {
       yield fromSnakeKeys(event);
     }
   }
-  async runMultipartRequest(path, inputs) {
+  async runMultipartRequest(path2, inputs) {
     const form = new FormData();
     for (const input of inputs) {
       form.append(
@@ -1256,7 +1561,7 @@ var CloudClient = class _CloudClient {
         input.name
       );
     }
-    return this.http.requestResponse("POST", path, {
+    return this.http.requestResponse("POST", path2, {
       body: form,
       headers: { Accept: "application/json" }
     });
@@ -1391,14 +1696,859 @@ var APIClient = class {
     return this.cloudClient.requestOutput(applicationName, requestId);
   }
 };
+
+// src/sandbox-image.ts
+import { readFile, readdir, stat } from "fs/promises";
+import path from "path";
+import { parseArgs } from "util";
+
+// src/image.ts
+import { randomUUID } from "crypto";
+var ImageBuildOperationType = {
+  ADD: "ADD",
+  COPY: "COPY",
+  ENV: "ENV",
+  RUN: "RUN",
+  WORKDIR: "WORKDIR"
+};
+function cloneOperation(op) {
+  return {
+    type: op.type,
+    args: [...op.args],
+    options: { ...op.options }
+  };
+}
+var Image = class {
+  _id;
+  _name;
+  _tag;
+  _baseImage;
+  _buildOperations;
+  constructor(nameOrOptions = {}, tag = "latest", baseImage = null) {
+    this._id = randomUUID();
+    this._buildOperations = [];
+    if (typeof nameOrOptions === "string") {
+      this._name = nameOrOptions;
+      this._tag = tag;
+      this._baseImage = baseImage;
+      return;
+    }
+    this._name = nameOrOptions.name ?? "default";
+    this._tag = nameOrOptions.tag ?? "latest";
+    this._baseImage = nameOrOptions.baseImage ?? null;
+  }
+  get name() {
+    return this._name;
+  }
+  get tag() {
+    return this._tag;
+  }
+  get baseImage() {
+    return this._baseImage;
+  }
+  get buildOperations() {
+    return this._buildOperations.map(cloneOperation);
+  }
+  add(src, dest, options = void 0) {
+    return this._addOperation({
+      type: ImageBuildOperationType.ADD,
+      args: [src, dest],
+      options: options == null ? {} : { ...options }
+    });
+  }
+  copy(src, dest, options = void 0) {
+    return this._addOperation({
+      type: ImageBuildOperationType.COPY,
+      args: [src, dest],
+      options: options == null ? {} : { ...options }
+    });
+  }
+  env(key, value) {
+    return this._addOperation({
+      type: ImageBuildOperationType.ENV,
+      args: [key, value],
+      options: {}
+    });
+  }
+  run(commands, options = void 0) {
+    return this._addOperation({
+      type: ImageBuildOperationType.RUN,
+      args: Array.isArray(commands) ? [...commands] : [commands],
+      options: options == null ? {} : { ...options }
+    });
+  }
+  workdir(directory) {
+    return this._addOperation({
+      type: ImageBuildOperationType.WORKDIR,
+      args: [directory],
+      options: {}
+    });
+  }
+  _addOperation(op) {
+    this._buildOperations.push(op);
+    return this;
+  }
+};
+function renderOptions(options) {
+  const entries = Object.entries(options);
+  if (entries.length === 0) {
+    return "";
+  }
+  return ` ${entries.map(([key, value]) => `--${key}=${value}`).join(" ")}`;
+}
+function renderBuildOp(op) {
+  const options = renderOptions(op.options);
+  if (op.type === ImageBuildOperationType.ENV) {
+    return `ENV${options} ${op.args[0]}=${JSON.stringify(op.args[1])}`;
+  }
+  return `${op.type}${options} ${op.args.join(" ")}`;
+}
+function dockerfileContent(image) {
+  const lines = image.baseImage == null ? [] : [`FROM ${image.baseImage}`];
+  lines.push(...image.buildOperations.map((op) => renderBuildOp(op)));
+  return lines.join("\n");
+}
+
+// src/sandbox-image.ts
+var BUILD_SANDBOX_PIP_ENV = { PIP_BREAK_SYSTEM_PACKAGES: "1" };
+var IGNORED_DOCKERFILE_INSTRUCTIONS = /* @__PURE__ */ new Set([
+  "CMD",
+  "ENTRYPOINT",
+  "EXPOSE",
+  "HEALTHCHECK",
+  "LABEL",
+  "STOPSIGNAL",
+  "VOLUME"
+]);
+var UNSUPPORTED_DOCKERFILE_INSTRUCTIONS = /* @__PURE__ */ new Set([
+  "ARG",
+  "ONBUILD",
+  "SHELL",
+  "USER"
+]);
+function defaultRegisteredName(dockerfilePath) {
+  const parsed = path.parse(dockerfilePath);
+  if (parsed.name.toLowerCase() === "dockerfile") {
+    const parentName = path.basename(path.dirname(dockerfilePath)).trim();
+    return parentName || "sandbox-image";
+  }
+  return parsed.name || "sandbox-image";
+}
+function logicalDockerfileLines(dockerfileText) {
+  const logicalLines = [];
+  let parts = [];
+  let startLine = null;
+  for (const [index, rawLine] of dockerfileText.split(/\r?\n/).entries()) {
+    const lineNumber = index + 1;
+    const stripped = rawLine.trim();
+    if (parts.length === 0 && (!stripped || stripped.startsWith("#"))) {
+      continue;
+    }
+    if (startLine == null) {
+      startLine = lineNumber;
+    }
+    let line = rawLine.replace(/\s+$/, "");
+    const continued = line.endsWith("\\");
+    if (continued) {
+      line = line.slice(0, -1);
+    }
+    const normalized = line.trim();
+    if (normalized && !normalized.startsWith("#")) {
+      parts.push(normalized);
+    }
+    if (continued) {
+      continue;
+    }
+    if (parts.length > 0) {
+      logicalLines.push({
+        lineNumber: startLine ?? lineNumber,
+        line: parts.join(" ")
+      });
+    }
+    parts = [];
+    startLine = null;
+  }
+  if (parts.length > 0) {
+    logicalLines.push({
+      lineNumber: startLine ?? 1,
+      line: parts.join(" ")
+    });
+  }
+  return logicalLines;
+}
+function splitInstruction(line, lineNumber) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    throw new Error(`line ${lineNumber}: empty Dockerfile instruction`);
+  }
+  const match = trimmed.match(/^(\S+)(?:\s+(.*))?$/);
+  if (!match) {
+    throw new Error(`line ${lineNumber}: invalid Dockerfile instruction`);
+  }
+  return {
+    keyword: match[1].toUpperCase(),
+    value: (match[2] ?? "").trim()
+  };
+}
+function shellSplit(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escape = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (escape) {
+      current += char;
+      escape = false;
+      continue;
+    }
+    if (quote == null) {
+      if (/\s/.test(char)) {
+        if (current) {
+          tokens.push(current);
+          current = "";
+        }
+        continue;
+      }
+      if (char === "'" || char === '"') {
+        quote = char;
+        continue;
+      }
+      if (char === "\\") {
+        escape = true;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (quote === "'") {
+      if (char === "'") {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"') {
+      quote = null;
+      continue;
+    }
+    if (char === "\\") {
+      const next = input[++i];
+      if (next == null) {
+        throw new Error(`unterminated escape sequence in '${input}'`);
+      }
+      current += next;
+      continue;
+    }
+    current += char;
+  }
+  if (escape) {
+    throw new Error(`unterminated escape sequence in '${input}'`);
+  }
+  if (quote != null) {
+    throw new Error(`unterminated quoted string in '${input}'`);
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function shellQuote(value) {
+  if (!value) {
+    return "''";
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function stripLeadingFlags(value) {
+  const flags = {};
+  let remaining = value.trimStart();
+  while (remaining.startsWith("--")) {
+    const firstSpace = remaining.indexOf(" ");
+    if (firstSpace === -1) {
+      throw new Error(`invalid Dockerfile flag syntax: ${value}`);
+    }
+    const token = remaining.slice(0, firstSpace);
+    const rest = remaining.slice(firstSpace + 1).trimStart();
+    const flagBody = token.slice(2);
+    if (flagBody.includes("=")) {
+      const [key, flagValue2] = flagBody.split(/=(.*)/s, 2);
+      flags[key] = flagValue2;
+      remaining = rest;
+      continue;
+    }
+    const [flagValue, ...restTokens] = shellSplit(rest);
+    if (flagValue == null) {
+      throw new Error(`missing value for Dockerfile flag '${token}'`);
+    }
+    flags[flagBody] = flagValue;
+    remaining = restTokens.join(" ");
+  }
+  return { flags, remaining };
+}
+function parseFromValue(value, lineNumber) {
+  const { remaining } = stripLeadingFlags(value);
+  const tokens = shellSplit(remaining);
+  if (tokens.length === 0) {
+    throw new Error(`line ${lineNumber}: FROM must include a base image`);
+  }
+  if (tokens.length > 1 && tokens[1].toLowerCase() !== "as") {
+    throw new Error(`line ${lineNumber}: unsupported FROM syntax '${value}'`);
+  }
+  return tokens[0];
+}
+function parseCopyLikeValues(value, lineNumber, keyword) {
+  const { flags, remaining } = stripLeadingFlags(value);
+  if ("from" in flags) {
+    throw new Error(
+      `line ${lineNumber}: ${keyword} --from is not supported for sandbox image creation`
+    );
+  }
+  const payload = remaining.trim();
+  if (!payload) {
+    throw new Error(
+      `line ${lineNumber}: ${keyword} must include source and destination`
+    );
+  }
+  let parts;
+  if (payload.startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch (error) {
+      throw new Error(
+        `line ${lineNumber}: invalid JSON array syntax for ${keyword}: ${error.message}`
+      );
+    }
+    if (!Array.isArray(parsed) || parsed.length < 2 || parsed.some((item) => typeof item !== "string")) {
+      throw new Error(
+        `line ${lineNumber}: ${keyword} JSON array form requires at least two string values`
+      );
+    }
+    parts = parsed;
+  } else {
+    parts = shellSplit(payload);
+    if (parts.length < 2) {
+      throw new Error(
+        `line ${lineNumber}: ${keyword} must include at least one source and one destination`
+      );
+    }
+  }
+  return {
+    flags,
+    sources: parts.slice(0, -1),
+    destination: parts[parts.length - 1]
+  };
+}
+function parseEnvPairs(value, lineNumber) {
+  const tokens = shellSplit(value);
+  if (tokens.length === 0) {
+    throw new Error(`line ${lineNumber}: ENV must include a key and value`);
+  }
+  if (tokens.every((token) => token.includes("="))) {
+    return tokens.map((token) => {
+      const [key, envValue] = token.split(/=(.*)/s, 2);
+      if (!key) {
+        throw new Error(`line ${lineNumber}: invalid ENV token '${token}'`);
+      }
+      return [key, envValue];
+    });
+  }
+  if (tokens.length < 2) {
+    throw new Error(`line ${lineNumber}: ENV must include a key and value`);
+  }
+  return [[tokens[0], tokens.slice(1).join(" ")]];
+}
+function resolveContainerPath(containerPath, workingDir) {
+  if (!containerPath) {
+    return workingDir;
+  }
+  const normalized = containerPath.startsWith("/") ? path.posix.normalize(containerPath) : path.posix.normalize(path.posix.join(workingDir, containerPath));
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+function buildPlanFromDockerfileText(dockerfileText, dockerfilePath, contextDir, registeredName) {
+  let baseImage;
+  const instructions = [];
+  for (const logicalLine of logicalDockerfileLines(dockerfileText)) {
+    const { keyword, value } = splitInstruction(
+      logicalLine.line,
+      logicalLine.lineNumber
+    );
+    if (keyword === "FROM") {
+      if (baseImage != null) {
+        throw new Error(
+          `line ${logicalLine.lineNumber}: multi-stage Dockerfiles are not supported for sandbox image creation`
+        );
+      }
+      baseImage = parseFromValue(value, logicalLine.lineNumber);
+      continue;
+    }
+    if (UNSUPPORTED_DOCKERFILE_INSTRUCTIONS.has(keyword)) {
+      throw new Error(
+        `line ${logicalLine.lineNumber}: Dockerfile instruction '${keyword}' is not supported for sandbox image creation`
+      );
+    }
+    instructions.push({
+      keyword,
+      value,
+      lineNumber: logicalLine.lineNumber
+    });
+  }
+  if (!baseImage) {
+    throw new Error("Dockerfile must contain a FROM instruction");
+  }
+  return {
+    dockerfilePath,
+    contextDir,
+    registeredName: registeredName ?? defaultRegisteredName(dockerfilePath),
+    dockerfileText,
+    baseImage,
+    instructions
+  };
+}
+async function loadDockerfilePlan(dockerfilePath, registeredName) {
+  const resolvedPath = path.resolve(dockerfilePath);
+  const fileStats = await stat(resolvedPath).catch(() => null);
+  if (!fileStats?.isFile()) {
+    throw new Error(`Dockerfile not found: ${dockerfilePath}`);
+  }
+  const dockerfileText = await readFile(resolvedPath, "utf8");
+  return buildPlanFromDockerfileText(
+    dockerfileText,
+    resolvedPath,
+    path.dirname(resolvedPath),
+    registeredName
+  );
+}
+function loadImagePlan(image, options = {}) {
+  const contextDir = path.resolve(options.contextDir ?? process.cwd());
+  const dockerfileText = dockerfileContent(image);
+  const logicalLines = logicalDockerfileLines(dockerfileText);
+  const instructions = image.baseImage == null ? logicalLines : logicalLines.slice(1);
+  return {
+    dockerfilePath: path.join(contextDir, "Dockerfile"),
+    contextDir,
+    registeredName: options.registeredName ?? image.name,
+    dockerfileText,
+    baseImage: image.baseImage ?? void 0,
+    instructions: instructions.map(({ line, lineNumber }) => {
+      const parsed = splitInstruction(line, lineNumber);
+      return {
+        keyword: parsed.keyword,
+        value: parsed.value,
+        lineNumber
+      };
+    })
+  };
+}
+function defaultEmit(event) {
+  process.stdout.write(`${JSON.stringify(event)}
+`);
+}
+function debugEnabled() {
+  return ["1", "true", "yes", "on"].includes(
+    (process.env.TENSORLAKE_DEBUG ?? "").toLowerCase()
+  );
+}
+function buildContextFromEnv() {
+  return {
+    apiUrl: process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai",
+    apiKey: process.env.TENSORLAKE_API_KEY,
+    personalAccessToken: process.env.TENSORLAKE_PAT,
+    namespace: process.env.INDEXIFY_NAMESPACE ?? "default",
+    organizationId: process.env.TENSORLAKE_ORGANIZATION_ID,
+    projectId: process.env.TENSORLAKE_PROJECT_ID,
+    debug: debugEnabled()
+  };
+}
+function createDefaultClient(context) {
+  return new SandboxClient({
+    apiUrl: context.apiUrl,
+    apiKey: context.apiKey ?? context.personalAccessToken,
+    organizationId: context.organizationId,
+    projectId: context.projectId,
+    namespace: context.namespace
+  });
+}
+async function runChecked(sandbox, command, args, env, workingDir) {
+  const result = await sandbox.run(command, {
+    args,
+    env,
+    workingDir
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Command '${command} ${args.join(" ")}' failed with exit code ${result.exitCode}`
+    );
+  }
+  return result;
+}
+async function runStreaming(sandbox, emit, sleep4, command, args = [], env, workingDir) {
+  const proc = await sandbox.startProcess(command, {
+    args,
+    env,
+    workingDir
+  });
+  let stdoutSeen = 0;
+  let stderrSeen = 0;
+  let info;
+  while (true) {
+    const stdoutResp = await sandbox.getStdout(proc.pid);
+    emitOutputLines(emit, "stdout", stdoutResp, stdoutSeen);
+    stdoutSeen = stdoutResp.lines.length;
+    const stderrResp = await sandbox.getStderr(proc.pid);
+    emitOutputLines(emit, "stderr", stderrResp, stderrSeen);
+    stderrSeen = stderrResp.lines.length;
+    info = await sandbox.getProcess(proc.pid);
+    if (info.status !== "running" /* RUNNING */) {
+      const finalStdout = await sandbox.getStdout(proc.pid);
+      emitOutputLines(emit, "stdout", finalStdout, stdoutSeen);
+      stdoutSeen = finalStdout.lines.length;
+      const finalStderr = await sandbox.getStderr(proc.pid);
+      emitOutputLines(emit, "stderr", finalStderr, stderrSeen);
+      break;
+    }
+    await sleep4(300);
+  }
+  for (let i = 0; i < 10; i++) {
+    if (info.exitCode != null || info.signal != null) {
+      break;
+    }
+    await sleep4(200);
+    info = await sandbox.getProcess(proc.pid);
+  }
+  const exitCode = info.exitCode != null ? info.exitCode : info.signal != null ? -info.signal : 0;
+  if (exitCode !== 0) {
+    throw new Error(
+      `Command '${command} ${args.join(" ")}' failed with exit code ${exitCode}`
+    );
+  }
+}
+function emitOutputLines(emit, stream, response, seen) {
+  for (const line of response.lines.slice(seen)) {
+    emit({ type: "build_log", stream, message: line });
+  }
+}
+function isPathWithinContext(contextDir, localPath) {
+  const relative = path.relative(contextDir, localPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolveContextSourcePath(contextDir, source) {
+  const resolvedContextDir = path.resolve(contextDir);
+  const resolvedSource = path.resolve(resolvedContextDir, source);
+  if (!isPathWithinContext(resolvedContextDir, resolvedSource)) {
+    throw new Error(`Local path escapes the build context: ${source}`);
+  }
+  return resolvedSource;
+}
+async function copyLocalPathToSandbox(sandbox, localPath, remotePath) {
+  const fileStats = await stat(localPath).catch(() => null);
+  if (!fileStats) {
+    throw new Error(`Local path not found: ${localPath}`);
+  }
+  if (fileStats.isFile()) {
+    await runChecked(sandbox, "mkdir", ["-p", path.posix.dirname(remotePath)]);
+    await sandbox.writeFile(remotePath, await readFile(localPath));
+    return;
+  }
+  if (!fileStats.isDirectory()) {
+    throw new Error(`Local path not found: ${localPath}`);
+  }
+  const entries = await readdir(localPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(localPath, entry.name);
+    const destinationPath = path.posix.join(remotePath, entry.name);
+    if (entry.isDirectory()) {
+      await runChecked(sandbox, "mkdir", ["-p", destinationPath]);
+      await copyLocalPathToSandbox(sandbox, sourcePath, destinationPath);
+    } else if (entry.isFile()) {
+      await runChecked(
+        sandbox,
+        "mkdir",
+        ["-p", path.posix.dirname(destinationPath)]
+      );
+      await sandbox.writeFile(destinationPath, await readFile(sourcePath));
+    }
+  }
+}
+async function persistEnvVar(sandbox, processEnv, key, value) {
+  const exportLine = `export ${key}=${shellQuote(value)}`;
+  await runChecked(
+    sandbox,
+    "sh",
+    ["-c", `printf '%s\\n' ${shellQuote(exportLine)} >> /etc/environment`],
+    processEnv
+  );
+}
+async function copyFromContext(sandbox, emit, contextDir, sources, destination, workingDir, keyword) {
+  const destinationPath = resolveContainerPath(destination, workingDir);
+  if (sources.length > 1 && !destinationPath.endsWith("/")) {
+    throw new Error(
+      `${keyword} with multiple sources requires a directory destination ending in '/'`
+    );
+  }
+  for (const source of sources) {
+    const localSource = resolveContextSourcePath(contextDir, source);
+    const localStats = await stat(localSource).catch(() => null);
+    if (!localStats) {
+      throw new Error(`Local path not found: ${localSource}`);
+    }
+    let remoteDestination = destinationPath;
+    if (sources.length > 1) {
+      remoteDestination = path.posix.join(
+        destinationPath.replace(/\/$/, ""),
+        path.posix.basename(source.replace(/\/$/, ""))
+      );
+    } else if (localStats.isFile() && destinationPath.endsWith("/")) {
+      remoteDestination = path.posix.join(
+        destinationPath.replace(/\/$/, ""),
+        path.basename(source)
+      );
+    }
+    emit({
+      type: "status",
+      message: `${keyword} ${source} -> ${remoteDestination}`
+    });
+    await copyLocalPathToSandbox(sandbox, localSource, remoteDestination);
+  }
+}
+async function addUrlToSandbox(sandbox, emit, url, destination, workingDir, processEnv, sleep4) {
+  let destinationPath = resolveContainerPath(destination, workingDir);
+  const parsedUrl = new URL(url);
+  const fileName = path.posix.basename(parsedUrl.pathname.replace(/\/$/, "")) || "downloaded";
+  if (destinationPath.endsWith("/")) {
+    destinationPath = path.posix.join(destinationPath.replace(/\/$/, ""), fileName);
+  }
+  const parentDir = path.posix.dirname(destinationPath) || "/";
+  emit({
+    type: "status",
+    message: `ADD ${url} -> ${destinationPath}`
+  });
+  await runChecked(sandbox, "mkdir", ["-p", parentDir], processEnv);
+  await runStreaming(
+    sandbox,
+    emit,
+    sleep4,
+    "sh",
+    [
+      "-c",
+      `curl -fsSL --location ${shellQuote(url)} -o ${shellQuote(destinationPath)}`
+    ],
+    processEnv,
+    workingDir
+  );
+}
+async function executeDockerfilePlan(sandbox, plan, emit, sleep4) {
+  const processEnv = { ...BUILD_SANDBOX_PIP_ENV };
+  let workingDir = "/";
+  for (const instruction of plan.instructions) {
+    const { keyword, value, lineNumber } = instruction;
+    if (keyword === "RUN") {
+      emit({ type: "status", message: `RUN ${value}` });
+      await runStreaming(
+        sandbox,
+        emit,
+        sleep4,
+        "sh",
+        ["-c", value],
+        processEnv,
+        workingDir
+      );
+      continue;
+    }
+    if (keyword === "WORKDIR") {
+      const tokens = shellSplit(value);
+      if (tokens.length !== 1) {
+        throw new Error(`line ${lineNumber}: WORKDIR must include exactly one path`);
+      }
+      workingDir = resolveContainerPath(tokens[0], workingDir);
+      emit({ type: "status", message: `WORKDIR ${workingDir}` });
+      await runChecked(sandbox, "mkdir", ["-p", workingDir], processEnv);
+      continue;
+    }
+    if (keyword === "ENV") {
+      for (const [key, envValue] of parseEnvPairs(value, lineNumber)) {
+        emit({ type: "status", message: `ENV ${key}=${envValue}` });
+        processEnv[key] = envValue;
+        await persistEnvVar(sandbox, processEnv, key, envValue);
+      }
+      continue;
+    }
+    if (keyword === "COPY") {
+      const { sources, destination } = parseCopyLikeValues(
+        value,
+        lineNumber,
+        keyword
+      );
+      await copyFromContext(
+        sandbox,
+        emit,
+        plan.contextDir,
+        sources,
+        destination,
+        workingDir,
+        keyword
+      );
+      continue;
+    }
+    if (keyword === "ADD") {
+      const { sources, destination } = parseCopyLikeValues(
+        value,
+        lineNumber,
+        keyword
+      );
+      if (sources.length === 1 && /^https?:\/\//.test(sources[0])) {
+        await addUrlToSandbox(
+          sandbox,
+          emit,
+          sources[0],
+          destination,
+          workingDir,
+          processEnv,
+          sleep4
+        );
+      } else {
+        await copyFromContext(
+          sandbox,
+          emit,
+          plan.contextDir,
+          sources,
+          destination,
+          workingDir,
+          keyword
+        );
+      }
+      continue;
+    }
+    if (IGNORED_DOCKERFILE_INSTRUCTIONS.has(keyword)) {
+      emit({
+        type: "warning",
+        message: `Skipping Dockerfile instruction '${keyword}' during snapshot materialization. It is still preserved in the registered Dockerfile.`
+      });
+      continue;
+    }
+    throw new Error(
+      `line ${lineNumber}: Dockerfile instruction '${keyword}' is not supported for sandbox image creation`
+    );
+  }
+}
+async function registerImage(context, name, dockerfile, snapshotId, snapshotUri, isPublic) {
+  if (!context.organizationId || !context.projectId) {
+    throw new Error(
+      "Organization ID and Project ID are required. Run 'tl login' and 'tl init'."
+    );
+  }
+  const bearerToken = context.apiKey ?? context.personalAccessToken;
+  if (!bearerToken) {
+    throw new Error("Missing TENSORLAKE_API_KEY or TENSORLAKE_PAT.");
+  }
+  const baseUrl = context.apiUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/platform/v1/organizations/${encodeURIComponent(context.organizationId)}/projects/${encodeURIComponent(context.projectId)}/sandbox-templates`;
+  const headers = {
+    Authorization: `Bearer ${bearerToken}`,
+    "Content-Type": "application/json"
+  };
+  if (context.personalAccessToken && !context.apiKey) {
+    headers["X-Forwarded-Organization-Id"] = context.organizationId;
+    headers["X-Forwarded-Project-Id"] = context.projectId;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      name,
+      dockerfile,
+      snapshotId,
+      snapshotUri,
+      isPublic
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `${response.status} ${response.statusText}: ${await response.text()}`
+    );
+  }
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+async function createSandboxImage(source, options = {}, deps = {}) {
+  const emit = deps.emit ?? defaultEmit;
+  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const context = buildContextFromEnv();
+  const clientFactory = deps.createClient ?? createDefaultClient;
+  const register = deps.registerImage ?? ((...args) => registerImage(...args));
+  const sourceLabel = typeof source === "string" ? source : `Image(${source.name})`;
+  emit({ type: "status", message: `Loading ${sourceLabel}...` });
+  const plan = typeof source === "string" ? await loadDockerfilePlan(source, options.registeredName) : loadImagePlan(source, options);
+  emit({
+    type: "status",
+    message: plan.baseImage == null ? "Starting build sandbox with the default server image..." : `Starting build sandbox from ${plan.baseImage}...`
+  });
+  const client = clientFactory(context);
+  let sandbox;
+  try {
+    sandbox = await client.createAndConnect({
+      ...plan.baseImage == null ? {} : { image: plan.baseImage },
+      cpus: options.cpus ?? 2,
+      memoryMb: options.memoryMb ?? 4096
+    });
+    emit({
+      type: "status",
+      message: `Materializing image in sandbox ${sandbox.sandboxId}...`
+    });
+    await executeDockerfilePlan(sandbox, plan, emit, sleep4);
+    emit({ type: "status", message: "Creating snapshot..." });
+    const snapshot = await client.snapshotAndWait(sandbox.sandboxId);
+    emit({
+      type: "snapshot_created",
+      snapshot_id: snapshot.snapshotId,
+      snapshot_uri: snapshot.snapshotUri ?? null
+    });
+    if (!snapshot.snapshotUri) {
+      throw new Error(
+        `Snapshot ${snapshot.snapshotId} is missing snapshotUri and cannot be registered as a sandbox image.`
+      );
+    }
+    emit({
+      type: "status",
+      message: `Registering image '${plan.registeredName}'...`
+    });
+    const result = await register(
+      context,
+      plan.registeredName,
+      plan.dockerfileText,
+      snapshot.snapshotId,
+      snapshot.snapshotUri,
+      options.isPublic ?? false
+    );
+    emit({
+      type: "image_registered",
+      name: plan.registeredName,
+      image_id: typeof result.id === "string" && result.id || typeof result.templateId === "string" && result.templateId || ""
+    });
+    emit({ type: "done" });
+    return result;
+  } finally {
+    if (sandbox) {
+      try {
+        await sandbox.terminate();
+      } catch {
+      }
+    }
+    client.close();
+  }
+}
 export {
   APIClient,
   CloudClient,
   ContainerState,
+  Image,
+  ImageBuildOperationType,
   OutputMode,
   PoolInUseError,
   PoolNotFoundError,
   ProcessStatus,
+  Pty,
   RemoteAPIError,
   RequestExecutionError,
   RequestFailedError,
@@ -1411,6 +2561,8 @@ export {
   SandboxNotFoundError,
   SandboxStatus,
   SnapshotStatus,
-  StdinMode
+  StdinMode,
+  createSandboxImage,
+  dockerfileContent
 };
 //# sourceMappingURL=index.js.map