modal 0.6.3 → 0.7.1

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   AlreadyExistsError: () => AlreadyExistsError,
   App: () => App2,
   AppService: () => AppService,
+  ClientClosedError: () => ClientClosedError,
   CloudBucketMount: () => CloudBucketMount2,
   CloudBucketMountService: () => CloudBucketMountService,
   Cls: () => Cls,
@@ -73,7 +74,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/app.ts
-var import_nice_grpc11 = require("nice-grpc");
+var import_nice_grpc12 = require("nice-grpc");
 
 // node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
 function varint64read() {
@@ -44280,8 +44281,8 @@ function isSet4(value) {
 }
 
 // src/client.ts
-var import_uuid = require("uuid");
-var import_nice_grpc10 = require("nice-grpc");
+var import_uuid2 = require("uuid");
+var import_nice_grpc11 = require("nice-grpc");
 
 // src/cloud_bucket_mount.ts
 var CloudBucketMountService = class {
@@ -44430,6 +44431,12 @@ var SandboxTimeoutError = class extends Error {
     this.name = "SandboxTimeoutError";
   }
 };
+var ClientClosedError = class extends Error {
+  constructor(message = "Unable to perform operation on a detached sandbox") {
+    super(message);
+    this.name = "ClientClosedError";
+  }
+};
 
 // src/function.ts
 var import_node_crypto = require("crypto");
@@ -46485,230 +46492,1874 @@ var Queue = class _Queue {
 };
 
 // src/sandbox.ts
-var import_nice_grpc8 = require("nice-grpc");
-var import_promises = require("timers/promises");
+var import_nice_grpc9 = require("nice-grpc");
+var import_promises2 = require("timers/promises");
 
-// src/sandbox_filesystem.ts
-var SandboxFile = class {
-  #client;
-  #fileDescriptor;
-  #taskId;
-  /** @ignore */
-  constructor(client2, fileDescriptor, taskId) {
-    this.#client = client2;
-    this.#fileDescriptor = fileDescriptor;
-    this.#taskId = taskId;
+// proto/modal_proto/task_command_router.ts
+function taskExecStderrConfigFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_EXEC_STDERR_CONFIG_DEVNULL":
+      return 0 /* TASK_EXEC_STDERR_CONFIG_DEVNULL */;
+    case 1:
+    case "TASK_EXEC_STDERR_CONFIG_PIPE":
+      return 1 /* TASK_EXEC_STDERR_CONFIG_PIPE */;
+    case 2:
+    case "TASK_EXEC_STDERR_CONFIG_STDOUT":
+      return 2 /* TASK_EXEC_STDERR_CONFIG_STDOUT */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
   }
-  /**
-   * Read data from the file.
-   * @returns Promise that resolves to the read data as Uint8Array
-   */
-  async read() {
-    const resp = await runFilesystemExec(this.#client.cpClient, {
-      fileReadRequest: {
-        fileDescriptor: this.#fileDescriptor
-      },
-      taskId: this.#taskId
-    });
-    const chunks = resp.chunks;
-    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
+}
+function taskExecStderrConfigToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_EXEC_STDERR_CONFIG_DEVNULL */:
+      return "TASK_EXEC_STDERR_CONFIG_DEVNULL";
+    case 1 /* TASK_EXEC_STDERR_CONFIG_PIPE */:
+      return "TASK_EXEC_STDERR_CONFIG_PIPE";
+    case 2 /* TASK_EXEC_STDERR_CONFIG_STDOUT */:
+      return "TASK_EXEC_STDERR_CONFIG_STDOUT";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
   }
-  /**
-   * Write data to the file.
-   * @param data - Data to write (string or Uint8Array)
-   */
-  async write(data) {
-    await runFilesystemExec(this.#client.cpClient, {
-      fileWriteRequest: {
-        fileDescriptor: this.#fileDescriptor,
-        data
-      },
-      taskId: this.#taskId
-    });
+}
+function taskExecStdioFileDescriptorFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT":
+      return 0 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT */;
+    case 1:
+    case "TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR":
+      return 1 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
   }
-  /**
-   * Flush any buffered data to the file.
-   */
-  async flush() {
-    await runFilesystemExec(this.#client.cpClient, {
-      fileFlushRequest: {
-        fileDescriptor: this.#fileDescriptor
-      },
-      taskId: this.#taskId
-    });
+}
+function taskExecStdioFileDescriptorToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT */:
+      return "TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT";
+    case 1 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR */:
+      return "TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
   }
-  /**
-   * Close the file handle.
-   */
-  async close() {
-    await runFilesystemExec(this.#client.cpClient, {
-      fileCloseRequest: {
-        fileDescriptor: this.#fileDescriptor
-      },
-      taskId: this.#taskId
-    });
+}
+function taskExecStdoutConfigFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_EXEC_STDOUT_CONFIG_DEVNULL":
+      return 0 /* TASK_EXEC_STDOUT_CONFIG_DEVNULL */;
+    case 1:
+    case "TASK_EXEC_STDOUT_CONFIG_PIPE":
+      return 1 /* TASK_EXEC_STDOUT_CONFIG_PIPE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
   }
-};
-async function runFilesystemExec(cpClient, request) {
-  const response = await cpClient.containerFilesystemExec(request);
-  const chunks = [];
-  let retries = 10;
-  let completed = false;
-  while (!completed) {
-    try {
-      const outputIterator = cpClient.containerFilesystemExecGetOutput({
-        execId: response.execId,
-        timeout: 55
-      });
-      for await (const batch of outputIterator) {
-        chunks.push(...batch.output);
-        if (batch.eof) {
-          completed = true;
-          break;
+}
+function taskExecStdoutConfigToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_EXEC_STDOUT_CONFIG_DEVNULL */:
+      return "TASK_EXEC_STDOUT_CONFIG_DEVNULL";
+    case 1 /* TASK_EXEC_STDOUT_CONFIG_PIPE */:
+      return "TASK_EXEC_STDOUT_CONFIG_PIPE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseTaskExecPollRequest() {
+  return { taskId: "", execId: "" };
+}
+var TaskExecPollRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.execId !== "") {
+      writer.uint32(18).string(message.execId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecPollRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
         }
-        if (batch.error !== void 0) {
-          if (retries > 0) {
-            retries--;
+        case 2: {
+          if (tag !== 18) {
             break;
           }
-          throw new SandboxFilesystemError(batch.error.errorMessage);
+          message.execId = reader.string();
+          continue;
         }
       }
-    } catch (err) {
-      if (isRetryableGrpc(err) && retries > 0) {
-        retries--;
-      } else throw err;
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      execId: isSet5(object.execId) ? globalThis.String(object.execId) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.execId !== "") {
+      obj.execId = message.execId;
     }
+    return obj;
+  },
+  create(base) {
+    return TaskExecPollRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecPollRequest();
+    message.taskId = object.taskId ?? "";
+    message.execId = object.execId ?? "";
+    return message;
   }
-  return { chunks, response };
-}
-
-// src/streams.ts
-function toModalReadStream(stream) {
-  return Object.assign(stream, readMixin);
-}
-function toModalWriteStream(stream) {
-  return Object.assign(stream, writeMixin);
+};
+function createBaseTaskExecPollResponse() {
+  return { code: void 0, signal: void 0 };
 }
-var readMixin = {
-  async readText() {
-    const reader = this.getReader();
-    try {
-      const decoder2 = new TextDecoder("utf-8");
-      const chunks = [];
-      while (true) {
-        const { value, done } = await reader.read();
-        if (value) {
-          if (typeof value === "string") chunks.push(value);
-          else {
-            chunks.push(decoder2.decode(value.buffer, { stream: true }));
+var TaskExecPollResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.code !== void 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    if (message.signal !== void 0) {
+      writer.uint32(16).int32(message.signal);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecPollResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
           }
+          message.code = reader.int32();
+          continue;
         }
-        if (done) {
-          chunks.push(decoder2.decode(void 0, { stream: false }));
-          break;
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.signal = reader.int32();
+          continue;
         }
       }
-      return chunks.join("");
-    } finally {
-      reader.releaseLock();
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
     }
+    return message;
   },
-  async readBytes() {
-    const chunks = [];
-    const reader = this.getReader();
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (value) {
-          if (typeof value === "string") {
-            chunks.push(new TextEncoder().encode(value));
-          } else {
-            chunks.push(value);
+  fromJSON(object) {
+    return {
+      code: isSet5(object.code) ? globalThis.Number(object.code) : void 0,
+      signal: isSet5(object.signal) ? globalThis.Number(object.signal) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.code !== void 0) {
+      obj.code = Math.round(message.code);
+    }
+    if (message.signal !== void 0) {
+      obj.signal = Math.round(message.signal);
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecPollResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecPollResponse();
+    message.code = object.code ?? void 0;
+    message.signal = object.signal ?? void 0;
+    return message;
+  }
+};
+function createBaseTaskExecStartRequest() {
+  return {
+    taskId: "",
+    execId: "",
+    commandArgs: [],
+    stdoutConfig: 0,
+    stderrConfig: 0,
+    timeoutSecs: void 0,
+    workdir: void 0,
+    secretIds: [],
+    ptyInfo: void 0,
+    runtimeDebug: false
+  };
+}
+var TaskExecStartRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.execId !== "") {
+      writer.uint32(18).string(message.execId);
+    }
+    for (const v of message.commandArgs) {
+      writer.uint32(26).string(v);
+    }
+    if (message.stdoutConfig !== 0) {
+      writer.uint32(32).int32(message.stdoutConfig);
+    }
+    if (message.stderrConfig !== 0) {
+      writer.uint32(40).int32(message.stderrConfig);
+    }
+    if (message.timeoutSecs !== void 0) {
+      writer.uint32(48).uint32(message.timeoutSecs);
+    }
+    if (message.workdir !== void 0) {
+      writer.uint32(58).string(message.workdir);
+    }
+    for (const v of message.secretIds) {
+      writer.uint32(66).string(v);
+    }
+    if (message.ptyInfo !== void 0) {
+      PTYInfo.encode(message.ptyInfo, writer.uint32(74).fork()).join();
+    }
+    if (message.runtimeDebug !== false) {
+      writer.uint32(80).bool(message.runtimeDebug);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStartRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
           }
+          message.execId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.commandArgs.push(reader.string());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.stdoutConfig = reader.int32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.stderrConfig = reader.int32();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.timeoutSecs = reader.uint32();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.workdir = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.secretIds.push(reader.string());
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.ptyInfo = PTYInfo.decode(reader, reader.uint32());
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+          message.runtimeDebug = reader.bool();
+          continue;
         }
-        if (done) break;
       }
-    } finally {
-      reader.releaseLock();
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
     }
-    let totalLength = 0;
-    for (const chunk of chunks) {
-      totalLength += chunk.length;
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      execId: isSet5(object.execId) ? globalThis.String(object.execId) : "",
+      commandArgs: globalThis.Array.isArray(object?.commandArgs) ? object.commandArgs.map((e) => globalThis.String(e)) : [],
+      stdoutConfig: isSet5(object.stdoutConfig) ? taskExecStdoutConfigFromJSON(object.stdoutConfig) : 0,
+      stderrConfig: isSet5(object.stderrConfig) ? taskExecStderrConfigFromJSON(object.stderrConfig) : 0,
+      timeoutSecs: isSet5(object.timeoutSecs) ? globalThis.Number(object.timeoutSecs) : void 0,
+      workdir: isSet5(object.workdir) ? globalThis.String(object.workdir) : void 0,
+      secretIds: globalThis.Array.isArray(object?.secretIds) ? object.secretIds.map((e) => globalThis.String(e)) : [],
+      ptyInfo: isSet5(object.ptyInfo) ? PTYInfo.fromJSON(object.ptyInfo) : void 0,
+      runtimeDebug: isSet5(object.runtimeDebug) ? globalThis.Boolean(object.runtimeDebug) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
     }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
+    if (message.execId !== "") {
+      obj.execId = message.execId;
     }
-    return result;
+    if (message.commandArgs?.length) {
+      obj.commandArgs = message.commandArgs;
+    }
+    if (message.stdoutConfig !== 0) {
+      obj.stdoutConfig = taskExecStdoutConfigToJSON(message.stdoutConfig);
+    }
+    if (message.stderrConfig !== 0) {
+      obj.stderrConfig = taskExecStderrConfigToJSON(message.stderrConfig);
+    }
+    if (message.timeoutSecs !== void 0) {
+      obj.timeoutSecs = Math.round(message.timeoutSecs);
+    }
+    if (message.workdir !== void 0) {
+      obj.workdir = message.workdir;
+    }
+    if (message.secretIds?.length) {
+      obj.secretIds = message.secretIds;
+    }
+    if (message.ptyInfo !== void 0) {
+      obj.ptyInfo = PTYInfo.toJSON(message.ptyInfo);
+    }
+    if (message.runtimeDebug !== false) {
+      obj.runtimeDebug = message.runtimeDebug;
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecStartRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecStartRequest();
+    message.taskId = object.taskId ?? "";
+    message.execId = object.execId ?? "";
+    message.commandArgs = object.commandArgs?.map((e) => e) || [];
+    message.stdoutConfig = object.stdoutConfig ?? 0;
+    message.stderrConfig = object.stderrConfig ?? 0;
+    message.timeoutSecs = object.timeoutSecs ?? void 0;
+    message.workdir = object.workdir ?? void 0;
+    message.secretIds = object.secretIds?.map((e) => e) || [];
+    message.ptyInfo = object.ptyInfo !== void 0 && object.ptyInfo !== null ? PTYInfo.fromPartial(object.ptyInfo) : void 0;
+    message.runtimeDebug = object.runtimeDebug ?? false;
+    return message;
   }
 };
-var writeMixin = {
-  async writeText(text) {
-    const writer = this.getWriter();
-    try {
-      await writer.write(text);
-    } finally {
-      writer.releaseLock();
-    }
+function createBaseTaskExecStartResponse() {
+  return {};
+}
+var TaskExecStartResponse = {
+  encode(_, writer = new BinaryWriter()) {
+    return writer;
   },
-  async writeBytes(bytes) {
-    const writer = this.getWriter();
-    try {
-      await writer.write(bytes);
-    } finally {
-      writer.releaseLock();
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStartResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
     }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return TaskExecStartResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseTaskExecStartResponse();
+    return message;
   }
 };
-function streamConsumingIter(iterable, onCancel) {
-  const iter = iterable[Symbol.asyncIterator]();
-  return new ReadableStream(
-    {
-      async pull(controller) {
-        const { done, value } = await iter.next();
-        if (value) {
-          controller.enqueue(value);
-        }
-        if (done) {
-          controller.close();
-        }
-      },
-      async cancel() {
-        try {
-          onCancel?.();
-        } finally {
-          if (typeof iter.return === "function") {
-            await iter.return();
-          }
-        }
-      }
-    },
-    new ByteLengthQueuingStrategy({
-      highWaterMark: 64 * 1024
-      // 64 KiB
-    })
-  );
+function createBaseTaskExecStdinWriteRequest() {
+  return { taskId: "", execId: "", offset: 0, data: new Uint8Array(0), eof: false };
 }
-
-// src/sandbox.ts
-var SB_LOGS_INITIAL_DELAY_MS = 10;
-var SB_LOGS_DELAY_FACTOR = 2;
-var SB_LOGS_MAX_RETRIES = 10;
-async function buildSandboxCreateRequestProto(appId, imageId, params = {}) {
-  checkForRenamedParams(params, {
-    memory: "memoryMiB",
-    memoryLimit: "memoryLimitMiB",
-    timeout: "timeoutMs",
+var TaskExecStdinWriteRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.execId !== "") {
+      writer.uint32(18).string(message.execId);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(24).uint64(message.offset);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(34).bytes(message.data);
+    }
+    if (message.eof !== false) {
+      writer.uint32(40).bool(message.eof);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStdinWriteRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.execId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.offset = longToNumber3(reader.uint64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.data = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.eof = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      execId: isSet5(object.execId) ? globalThis.String(object.execId) : "",
+      offset: isSet5(object.offset) ? globalThis.Number(object.offset) : 0,
+      data: isSet5(object.data) ? bytesFromBase642(object.data) : new Uint8Array(0),
+      eof: isSet5(object.eof) ? globalThis.Boolean(object.eof) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.execId !== "") {
+      obj.execId = message.execId;
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    if (message.data.length !== 0) {
+      obj.data = base64FromBytes2(message.data);
+    }
+    if (message.eof !== false) {
+      obj.eof = message.eof;
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecStdinWriteRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecStdinWriteRequest();
+    message.taskId = object.taskId ?? "";
+    message.execId = object.execId ?? "";
+    message.offset = object.offset ?? 0;
+    message.data = object.data ?? new Uint8Array(0);
+    message.eof = object.eof ?? false;
+    return message;
+  }
+};
+function createBaseTaskExecStdinWriteResponse() {
+  return {};
+}
+var TaskExecStdinWriteResponse = {
+  encode(_, writer = new BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStdinWriteResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return TaskExecStdinWriteResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseTaskExecStdinWriteResponse();
+    return message;
+  }
+};
+function createBaseTaskExecStdioReadRequest() {
+  return { taskId: "", execId: "", offset: 0, fileDescriptor: 0 };
+}
+var TaskExecStdioReadRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.execId !== "") {
+      writer.uint32(18).string(message.execId);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(24).uint64(message.offset);
+    }
+    if (message.fileDescriptor !== 0) {
+      writer.uint32(32).int32(message.fileDescriptor);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStdioReadRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.execId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.offset = longToNumber3(reader.uint64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.fileDescriptor = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      execId: isSet5(object.execId) ? globalThis.String(object.execId) : "",
+      offset: isSet5(object.offset) ? globalThis.Number(object.offset) : 0,
+      fileDescriptor: isSet5(object.fileDescriptor) ? taskExecStdioFileDescriptorFromJSON(object.fileDescriptor) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.execId !== "") {
+      obj.execId = message.execId;
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    if (message.fileDescriptor !== 0) {
+      obj.fileDescriptor = taskExecStdioFileDescriptorToJSON(message.fileDescriptor);
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecStdioReadRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecStdioReadRequest();
+    message.taskId = object.taskId ?? "";
+    message.execId = object.execId ?? "";
+    message.offset = object.offset ?? 0;
+    message.fileDescriptor = object.fileDescriptor ?? 0;
+    return message;
+  }
+};
+function createBaseTaskExecStdioReadResponse() {
+  return { data: new Uint8Array(0) };
+}
+var TaskExecStdioReadResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecStdioReadResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.data = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { data: isSet5(object.data) ? bytesFromBase642(object.data) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.data.length !== 0) {
+      obj.data = base64FromBytes2(message.data);
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecStdioReadResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecStdioReadResponse();
+    message.data = object.data ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseTaskExecWaitRequest() {
+  return { taskId: "", execId: "" };
+}
+var TaskExecWaitRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.execId !== "") {
+      writer.uint32(18).string(message.execId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecWaitRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.execId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      execId: isSet5(object.execId) ? globalThis.String(object.execId) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.execId !== "") {
+      obj.execId = message.execId;
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecWaitRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecWaitRequest();
+    message.taskId = object.taskId ?? "";
+    message.execId = object.execId ?? "";
+    return message;
+  }
+};
+function createBaseTaskExecWaitResponse() {
+  return { code: void 0, signal: void 0 };
+}
+var TaskExecWaitResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.code !== void 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    if (message.signal !== void 0) {
+      writer.uint32(16).int32(message.signal);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskExecWaitResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.code = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.signal = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      code: isSet5(object.code) ? globalThis.Number(object.code) : void 0,
+      signal: isSet5(object.signal) ? globalThis.Number(object.signal) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.code !== void 0) {
+      obj.code = Math.round(message.code);
+    }
+    if (message.signal !== void 0) {
+      obj.signal = Math.round(message.signal);
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskExecWaitResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskExecWaitResponse();
+    message.code = object.code ?? void 0;
+    message.signal = object.signal ?? void 0;
+    return message;
+  }
+};
+function createBaseTaskMountDirectoryRequest() {
+  return { taskId: "", path: new Uint8Array(0), imageId: "" };
+}
+var TaskMountDirectoryRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.path.length !== 0) {
+      writer.uint32(18).bytes(message.path);
+    }
+    if (message.imageId !== "") {
+      writer.uint32(26).string(message.imageId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskMountDirectoryRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.path = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.imageId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      path: isSet5(object.path) ? bytesFromBase642(object.path) : new Uint8Array(0),
+      imageId: isSet5(object.imageId) ? globalThis.String(object.imageId) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.path.length !== 0) {
+      obj.path = base64FromBytes2(message.path);
+    }
+    if (message.imageId !== "") {
+      obj.imageId = message.imageId;
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskMountDirectoryRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskMountDirectoryRequest();
+    message.taskId = object.taskId ?? "";
+    message.path = object.path ?? new Uint8Array(0);
+    message.imageId = object.imageId ?? "";
+    return message;
+  }
+};
+function createBaseTaskSnapshotDirectoryRequest() {
+  return { taskId: "", path: new Uint8Array(0) };
+}
+var TaskSnapshotDirectoryRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.path.length !== 0) {
+      writer.uint32(18).bytes(message.path);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskSnapshotDirectoryRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.path = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      taskId: isSet5(object.taskId) ? globalThis.String(object.taskId) : "",
+      path: isSet5(object.path) ? bytesFromBase642(object.path) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.path.length !== 0) {
+      obj.path = base64FromBytes2(message.path);
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskSnapshotDirectoryRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskSnapshotDirectoryRequest();
+    message.taskId = object.taskId ?? "";
+    message.path = object.path ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseTaskSnapshotDirectoryResponse() {
+  return { imageId: "" };
+}
+var TaskSnapshotDirectoryResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.imageId !== "") {
+      writer.uint32(10).string(message.imageId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskSnapshotDirectoryResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.imageId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { imageId: isSet5(object.imageId) ? globalThis.String(object.imageId) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.imageId !== "") {
+      obj.imageId = message.imageId;
+    }
+    return obj;
+  },
+  create(base) {
+    return TaskSnapshotDirectoryResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTaskSnapshotDirectoryResponse();
+    message.imageId = object.imageId ?? "";
+    return message;
+  }
+};
+var TaskCommandRouterDefinition = {
+  name: "TaskCommandRouter",
+  fullName: "modal.task_command_router.TaskCommandRouter",
+  methods: {
+    /** Poll for the exit status of an exec'd command. */
+    taskExecPoll: {
+      name: "TaskExecPoll",
+      requestType: TaskExecPollRequest,
+      requestStream: false,
+      responseType: TaskExecPollResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Execute a command in the task. */
+    taskExecStart: {
+      name: "TaskExecStart",
+      requestType: TaskExecStartRequest,
+      requestStream: false,
+      responseType: TaskExecStartResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Write to the stdin stream of an exec'd command. */
+    taskExecStdinWrite: {
+      name: "TaskExecStdinWrite",
+      requestType: TaskExecStdinWriteRequest,
+      requestStream: false,
+      responseType: TaskExecStdinWriteResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Get a stream of output from the stdout or stderr stream of an exec'd command. */
+    taskExecStdioRead: {
+      name: "TaskExecStdioRead",
+      requestType: TaskExecStdioReadRequest,
+      requestStream: false,
+      responseType: TaskExecStdioReadResponse,
+      responseStream: true,
+      options: {}
+    },
+    /** Wait for an exec'd command to exit and return the exit code. */
+    taskExecWait: {
+      name: "TaskExecWait",
+      requestType: TaskExecWaitRequest,
+      requestStream: false,
+      responseType: TaskExecWaitResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Mount an image at a directory in the container. */
+    taskMountDirectory: {
+      name: "TaskMountDirectory",
+      requestType: TaskMountDirectoryRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    },
+    /** Snapshot a directory with a mounted image, including any local changes, into a new image. */
+    taskSnapshotDirectory: {
+      name: "TaskSnapshotDirectory",
+      requestType: TaskSnapshotDirectoryRequest,
+      requestStream: false,
+      responseType: TaskSnapshotDirectoryResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase642(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes2(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function longToNumber3(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+function isSet5(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/task_command_router_client.ts
+var import_promises = require("timers/promises");
+var import_nice_grpc8 = require("nice-grpc");
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = __toESM(require("path"), 1);
+var import_smol_toml = require("smol-toml");
+function isLocalhost(profile) {
+  const url = new URL(profile.serverUrl);
+  const hostname = url.hostname;
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "172.21.0.1";
+}
+function configFilePath() {
+  const configPath = process.env["MODAL_CONFIG_PATH"];
+  if (configPath && configPath !== "") {
+    return configPath;
+  }
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".modal.toml");
+}
+function readConfigFile() {
+  try {
+    const configPath = configFilePath();
+    const configContent = (0, import_node_fs.readFileSync)(configPath, {
+      encoding: "utf-8"
+    });
+    return (0, import_smol_toml.parse)(configContent);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    return {};
+  }
+}
+var config = readConfigFile();
+function getProfile(profileName) {
+  if (!profileName) {
+    for (const [name, profileData2] of Object.entries(config)) {
+      if (profileData2.active) {
+        profileName = name;
+        break;
+      }
+    }
+  }
+  const profileData = profileName && Object.hasOwn(config, profileName) ? config[profileName] : {};
+  const profile = {
+    serverUrl: process.env["MODAL_SERVER_URL"] || profileData.server_url || "https://api.modal.com:443",
+    tokenId: process.env["MODAL_TOKEN_ID"] || profileData.token_id,
+    tokenSecret: process.env["MODAL_TOKEN_SECRET"] || profileData.token_secret,
+    environment: process.env["MODAL_ENVIRONMENT"] || profileData.environment,
+    imageBuilderVersion: process.env["MODAL_IMAGE_BUILDER_VERSION"] || profileData.imageBuilderVersion,
+    logLevel: process.env["MODAL_LOGLEVEL"] || profileData.loglevel
+  };
+  return profile;
+}
+
+// src/task_command_router_client.ts
+function parseJwtExpiration(jwtToken, logger) {
+  try {
+    const parts = jwtToken.split(".");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const payloadB64 = parts[1];
+    const padding = "=".repeat((4 - payloadB64.length % 4) % 4);
+    const payloadJson = Buffer.from(payloadB64 + padding, "base64").toString(
+      "utf8"
+    );
+    const payload = JSON.parse(payloadJson);
+    const exp = payload.exp;
+    if (typeof exp === "number") {
+      return exp;
+    }
+  } catch (e) {
+    logger.warn("Failed to parse JWT expiration", "error", e);
+  }
+  return null;
+}
+async function callWithRetriesOnTransientErrors(func, baseDelayMs = 10, delayFactor = 2, maxRetries = 10, deadlineMs = null, isClosed) {
+  let delayMs = baseDelayMs;
+  let numRetries = 0;
+  const retryableStatusCodes = /* @__PURE__ */ new Set([
+    import_nice_grpc8.Status.DEADLINE_EXCEEDED,
+    import_nice_grpc8.Status.UNAVAILABLE,
+    import_nice_grpc8.Status.CANCELLED,
+    import_nice_grpc8.Status.INTERNAL,
+    import_nice_grpc8.Status.UNKNOWN
+  ]);
+  while (true) {
+    if (deadlineMs !== null && Date.now() >= deadlineMs) {
+      throw new Error("Deadline exceeded");
+    }
+    try {
+      return await func();
+    } catch (err) {
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.CANCELLED && isClosed?.()) {
+        throw new ClientClosedError();
+      }
+      if (err instanceof import_nice_grpc8.ClientError && retryableStatusCodes.has(err.code) && (maxRetries === null || numRetries < maxRetries)) {
+        if (deadlineMs !== null && Date.now() + delayMs >= deadlineMs) {
+          throw new Error("Deadline exceeded");
+        }
+        await (0, import_promises.setTimeout)(delayMs);
+        delayMs *= delayFactor;
+        numRetries++;
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
+  stub;
+  channel;
+  serverClient;
+  taskId;
+  serverUrl;
+  jwt;
+  jwtExp;
+  jwtRefreshLock = Promise.resolve();
+  logger;
+  closed = false;
+  static async tryInit(serverClient, taskId, logger, profile) {
+    let resp;
+    try {
+      resp = await serverClient.taskGetCommandRouterAccess(
+        TaskGetCommandRouterAccessRequest.create({ taskId })
+      );
+    } catch (err) {
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.FAILED_PRECONDITION) {
+        logger.debug(
+          "Command router access is not enabled for task",
+          "task_id",
+          taskId
+        );
+        return null;
+      }
+      throw err;
+    }
+    logger.debug(
+      "Using command router access for task",
+      "task_id",
+      taskId,
+      "url",
+      resp.url
+    );
+    const url = new URL(resp.url);
+    if (url.protocol !== "https:") {
+      throw new Error(`Task router URL must be https, got: ${resp.url}`);
+    }
+    const host = url.hostname;
+    const port = url.port ? parseInt(url.port) : 443;
+    const serverUrl = `${host}:${port}`;
+    const channelConfig = {
+      "grpc.max_receive_message_length": 100 * 1024 * 1024,
+      "grpc.max_send_message_length": 100 * 1024 * 1024,
+      "grpc-node.flow_control_window": 64 * 1024 * 1024,
+      "grpc.keepalive_time_ms": 3e4,
+      "grpc.keepalive_timeout_ms": 1e4,
+      "grpc.keepalive_permit_without_calls": 1
+    };
+    let channel;
+    if (isLocalhost(profile)) {
+      logger.warn(
+        "Using insecure TLS (skip certificate verification) for task command router"
+      );
+      channel = (0, import_nice_grpc8.createChannel)(
+        serverUrl,
+        import_nice_grpc8.ChannelCredentials.createInsecure(),
+        channelConfig
+      );
+    } else {
+      channel = (0, import_nice_grpc8.createChannel)(
+        serverUrl,
+        import_nice_grpc8.ChannelCredentials.createSsl(),
+        channelConfig
+      );
+    }
+    const client2 = new _TaskCommandRouterClientImpl(
+      serverClient,
+      taskId,
+      resp.url,
+      resp.jwt,
+      channel,
+      logger
+    );
+    logger.debug(
+      "Successfully initialized command router client",
+      "task_id",
+      taskId
+    );
+    return client2;
+  }
+  constructor(serverClient, taskId, serverUrl, jwt, channel, logger) {
+    this.serverClient = serverClient;
+    this.taskId = taskId;
+    this.serverUrl = serverUrl;
+    this.jwt = jwt;
+    this.jwtExp = parseJwtExpiration(jwt, logger);
+    this.logger = logger;
+    this.channel = channel;
+    const self = this;
+    const factory = (0, import_nice_grpc8.createClientFactory)().use(timeoutMiddleware).use(async function* authMiddleware(call, options) {
+      options.metadata ??= new import_nice_grpc8.Metadata();
+      options.metadata.set("authorization", `Bearer ${self.jwt}`);
+      return yield* call.next(call.request, options);
+    });
+    this.stub = factory.create(TaskCommandRouterDefinition, channel);
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.channel.close();
+  }
+  async execStart(request) {
+    return await callWithRetriesOnTransientErrors(
+      () => this.callWithAuthRetry(() => this.stub.taskExecStart(request)),
+      10,
+      2,
+      10,
+      null,
+      () => this.closed
+    );
+  }
+  async *execStdioRead(taskId, execId, fileDescriptor, deadline = null) {
+    let srFd;
+    if (fileDescriptor === 1 /* FILE_DESCRIPTOR_STDOUT */) {
+      srFd = 0 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT */;
+    } else if (fileDescriptor === 2 /* FILE_DESCRIPTOR_STDERR */) {
+      srFd = 1 /* TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR */;
+    } else if (fileDescriptor === 3 /* FILE_DESCRIPTOR_INFO */ || fileDescriptor === 0 /* FILE_DESCRIPTOR_UNSPECIFIED */) {
+      throw new Error(`Unsupported file descriptor: ${fileDescriptor}`);
+    } else {
+      throw new Error(`Invalid file descriptor: ${fileDescriptor}`);
+    }
+    yield* this.streamStdio(taskId, execId, srFd, deadline);
+  }
+  async execStdinWrite(taskId, execId, offset, data, eof) {
+    const request = TaskExecStdinWriteRequest.create({
+      taskId,
+      execId,
+      offset,
+      data,
+      eof
+    });
+    return await callWithRetriesOnTransientErrors(
+      () => this.callWithAuthRetry(() => this.stub.taskExecStdinWrite(request)),
+      10,
+      2,
+      10,
+      null,
+      () => this.closed
+    );
+  }
+  async execPoll(taskId, execId, deadline = null) {
+    const request = TaskExecPollRequest.create({ taskId, execId });
+    if (deadline && deadline <= Date.now()) {
+      throw new Error(`Deadline exceeded while polling for exec ${execId}`);
+    }
+    try {
+      return await callWithRetriesOnTransientErrors(
+        () => this.callWithAuthRetry(() => this.stub.taskExecPoll(request)),
+        10,
+        // baseDelayMs
+        2,
+        // delayFactor
+        10,
+        // maxRetries
+        deadline,
+        // Enforce overall deadline.
+        () => this.closed
+      );
+    } catch (err) {
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.DEADLINE_EXCEEDED) {
+        throw new Error(`Deadline exceeded while polling for exec ${execId}`);
+      }
+      throw err;
+    }
+  }
+  async execWait(taskId, execId, deadline = null) {
+    const request = TaskExecWaitRequest.create({ taskId, execId });
+    if (deadline && deadline <= Date.now()) {
+      throw new Error(`Deadline exceeded while waiting for exec ${execId}`);
+    }
+    try {
+      return await callWithRetriesOnTransientErrors(
+        () => this.callWithAuthRetry(
+          () => this.stub.taskExecWait(request, {
+            timeoutMs: 6e4
+          })
+        ),
+        1e3,
+        // Retry after 1s since total time is expected to be long.
+        1,
+        // Fixed delay.
+        null,
+        // Retry forever.
+        deadline,
+        // Enforce overall deadline.
+        () => this.closed
+      );
+    } catch (err) {
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.DEADLINE_EXCEEDED) {
+        throw new Error(`Deadline exceeded while waiting for exec ${execId}`);
+      }
+      throw err;
+    }
+  }
+  async mountDirectory(request) {
+    await callWithRetriesOnTransientErrors(
+      () => this.callWithAuthRetry(() => this.stub.taskMountDirectory(request)),
+      10,
+      2,
+      10,
+      null,
+      () => this.closed
+    );
+  }
+  async snapshotDirectory(request) {
+    return await callWithRetriesOnTransientErrors(
+      () => this.callWithAuthRetry(() => this.stub.taskSnapshotDirectory(request)),
+      10,
+      2,
+      10,
+      null,
+      () => this.closed
+    );
+  }
+  async refreshJwt() {
+    let error;
+    this.jwtRefreshLock = this.jwtRefreshLock.then(async () => {
+      if (this.closed) {
+        return;
+      }
+      if (this.jwtExp !== null && this.jwtExp - Date.now() / 1e3 > 30) {
+        this.logger.debug(
+          "Skipping JWT refresh because expiration is far enough in the future",
+          "task_id",
+          this.taskId
+        );
+        return;
+      }
+      try {
+        const resp = await this.serverClient.taskGetCommandRouterAccess(
+          TaskGetCommandRouterAccessRequest.create({ taskId: this.taskId })
+        );
+        if (resp.url !== this.serverUrl) {
+          throw new Error("Task router URL changed during session");
+        }
+        this.jwt = resp.jwt;
+        this.jwtExp = parseJwtExpiration(resp.jwt, this.logger);
+      } catch (err) {
+        error = err;
+      }
+    });
+    await this.jwtRefreshLock;
+    if (error) {
+      throw error;
+    }
+  }
+  async callWithAuthRetry(func) {
+    try {
+      return await func();
+    } catch (err) {
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.UNAUTHENTICATED) {
+        await this.refreshJwt();
+        return await func();
+      }
+      throw err;
+    }
+  }
+  async *streamStdio(taskId, execId, fileDescriptor, deadline) {
+    let offset = 0;
+    let delayMs = 10;
+    const delayFactor = 2;
+    let numRetriesRemaining = 10;
+    let didAuthRetry = false;
+    const retryableStatusCodes = /* @__PURE__ */ new Set([
+      import_nice_grpc8.Status.DEADLINE_EXCEEDED,
+      import_nice_grpc8.Status.UNAVAILABLE,
+      import_nice_grpc8.Status.CANCELLED,
+      import_nice_grpc8.Status.INTERNAL,
+      import_nice_grpc8.Status.UNKNOWN
+    ]);
+    while (true) {
+      try {
+        const timeoutMs = deadline !== null ? Math.max(0, deadline - Date.now()) : void 0;
+        const request = TaskExecStdioReadRequest.create({
+          taskId,
+          execId,
+          offset,
+          fileDescriptor
+        });
+        const stream = this.stub.taskExecStdioRead(request, {
+          timeoutMs
+        });
+        try {
+          for await (const item of stream) {
+            if (didAuthRetry) {
+              didAuthRetry = false;
+            }
+            delayMs = 10;
+            offset += item.data.length;
+            yield item;
+          }
+          return;
+        } catch (err) {
+          if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.UNAUTHENTICATED && !didAuthRetry) {
+            await this.refreshJwt();
+            didAuthRetry = true;
+            continue;
+          }
+          throw err;
+        }
+      } catch (err) {
+        if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.CANCELLED && this.closed) {
+          throw new ClientClosedError();
+        }
+        if (err instanceof import_nice_grpc8.ClientError && retryableStatusCodes.has(err.code) && numRetriesRemaining > 0) {
+          if (deadline && deadline - Date.now() <= delayMs) {
+            throw new Error(
+              `Deadline exceeded while streaming stdio for exec ${execId}`
+            );
+          }
+          this.logger.debug(
+            "Retrying stdio read with delay",
+            "delay_ms",
+            delayMs,
+            "error",
+            err
+          );
+          await (0, import_promises.setTimeout)(delayMs);
+          delayMs *= delayFactor;
+          numRetriesRemaining--;
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+};
+
+// src/sandbox.ts
+var import_uuid = require("uuid");
+
+// src/sandbox_filesystem.ts
+var SandboxFile = class {
+  #client;
+  #fileDescriptor;
+  #taskId;
+  /** @ignore */
+  constructor(client2, fileDescriptor, taskId) {
+    this.#client = client2;
+    this.#fileDescriptor = fileDescriptor;
+    this.#taskId = taskId;
+  }
+  /**
+   * Read data from the file.
+   * @returns Promise that resolves to the read data as Uint8Array
+   */
+  async read() {
+    const resp = await runFilesystemExec(this.#client.cpClient, {
+      fileReadRequest: {
+        fileDescriptor: this.#fileDescriptor
+      },
+      taskId: this.#taskId
+    });
+    const chunks = resp.chunks;
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  /**
+   * Write data to the file.
+   * @param data - Data to write (string or Uint8Array)
+   */
+  async write(data) {
+    await runFilesystemExec(this.#client.cpClient, {
+      fileWriteRequest: {
+        fileDescriptor: this.#fileDescriptor,
+        data
+      },
+      taskId: this.#taskId
+    });
+  }
+  /**
+   * Flush any buffered data to the file.
+   */
+  async flush() {
+    await runFilesystemExec(this.#client.cpClient, {
+      fileFlushRequest: {
+        fileDescriptor: this.#fileDescriptor
+      },
+      taskId: this.#taskId
+    });
+  }
+  /**
+   * Close the file handle.
+   */
+  async close() {
+    await runFilesystemExec(this.#client.cpClient, {
+      fileCloseRequest: {
+        fileDescriptor: this.#fileDescriptor
+      },
+      taskId: this.#taskId
+    });
+  }
+};
+async function runFilesystemExec(cpClient, request) {
+  const response = await cpClient.containerFilesystemExec(request);
+  const chunks = [];
+  let retries = 10;
+  let completed = false;
+  while (!completed) {
+    try {
+      const outputIterator = cpClient.containerFilesystemExecGetOutput({
+        execId: response.execId,
+        timeout: 55
+      });
+      for await (const batch of outputIterator) {
+        chunks.push(...batch.output);
+        if (batch.eof) {
+          completed = true;
+          break;
+        }
+        if (batch.error !== void 0) {
+          if (retries > 0) {
+            retries--;
+            break;
+          }
+          throw new SandboxFilesystemError(batch.error.errorMessage);
+        }
+      }
+    } catch (err) {
+      if (isRetryableGrpc(err) && retries > 0) {
+        retries--;
+      } else throw err;
+    }
+  }
+  return { chunks, response };
+}
+
+// src/streams.ts
+function toModalReadStream(stream) {
+  return Object.assign(stream, readMixin);
+}
+function toModalWriteStream(stream) {
+  return Object.assign(stream, writeMixin);
+}
+var readMixin = {
+  async readText() {
+    const reader = this.getReader();
+    try {
+      const decoder2 = new TextDecoder("utf-8");
+      const chunks = [];
+      while (true) {
+        const { value, done } = await reader.read();
+        if (value) {
+          if (typeof value === "string") chunks.push(value);
+          else {
+            chunks.push(decoder2.decode(value.buffer, { stream: true }));
+          }
+        }
+        if (done) {
+          chunks.push(decoder2.decode(void 0, { stream: false }));
+          break;
+        }
+      }
+      return chunks.join("");
+    } finally {
+      reader.releaseLock();
+    }
+  },
+  async readBytes() {
+    const chunks = [];
+    const reader = this.getReader();
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (value) {
+          if (typeof value === "string") {
+            chunks.push(new TextEncoder().encode(value));
+          } else {
+            chunks.push(value);
+          }
+        }
+        if (done) break;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    let totalLength = 0;
+    for (const chunk of chunks) {
+      totalLength += chunk.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+};
+var writeMixin = {
+  async writeText(text) {
+    const writer = this.getWriter();
+    try {
+      await writer.write(text);
+    } finally {
+      writer.releaseLock();
+    }
+  },
+  async writeBytes(bytes) {
+    const writer = this.getWriter();
+    try {
+      await writer.write(bytes);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+};
+function streamConsumingIter(iterable, onCancel) {
+  const iter = iterable[Symbol.asyncIterator]();
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        const { done, value } = await iter.next();
+        if (value) {
+          controller.enqueue(value);
+        }
+        if (done) {
+          controller.close();
+        }
+      },
+      async cancel() {
+        try {
+          onCancel?.();
+        } finally {
+          if (typeof iter.return === "function") {
+            await iter.return();
+          }
+        }
+      }
+    },
+    new ByteLengthQueuingStrategy({
+      highWaterMark: 64 * 1024
+      // 64 KiB
+    })
+  );
+}
+
+// src/sandbox.ts
+var SB_LOGS_INITIAL_DELAY_MS = 10;
+var SB_LOGS_DELAY_FACTOR = 2;
+var SB_LOGS_MAX_RETRIES = 10;
+async function buildSandboxCreateRequestProto(appId, imageId, params = {}) {
+  checkForRenamedParams(params, {
+    memory: "memoryMiB",
+    memoryLimit: "memoryLimitMiB",
+    timeout: "timeoutMs",
     idleTimeout: "idleTimeoutMs"
   });
   const gpuConfig = parseGpuConfig(params.gpu);
@@ -46919,7 +48570,7 @@ var SandboxService = class {
     try {
       createResp = await this.#client.cpClient.sandboxCreate(createReq);
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.ALREADY_EXISTS) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.ALREADY_EXISTS) {
         throw new AlreadyExistsError(err.details || err.message);
       }
       throw err;
@@ -46942,7 +48593,7 @@ var SandboxService = class {
         timeout: 0
       });
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND)
         throw new NotFoundError(`Sandbox with id: '${sandboxId}' not found`);
       throw err;
     }
@@ -46967,7 +48618,7 @@ var SandboxService = class {
       });
       return new Sandbox2(this.#client, resp.sandboxId);
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND)
         throw new NotFoundError(
           `Sandbox with name '${name}' not found in App '${appName}'`
         );
@@ -47002,7 +48653,7 @@ var SandboxService = class {
         }
         beforeTimestamp = resp.sandboxes[resp.sandboxes.length - 1].createdAt;
       } catch (err) {
-        if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.INVALID_ARGUMENT) {
+        if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
           throw new InvalidError(err.details || err.message);
         }
         throw err;
@@ -47052,7 +48703,16 @@ function defaultSandboxPTYInfo() {
     noTerminateOnIdleStdin: true
   });
 }
-async function buildContainerExecRequestProto(taskId, command, params) {
+function validateExecArgs(args) {
+  const ARG_MAX_BYTES = 2 ** 16;
+  const totalArgLen = args.reduce((sum, arg) => sum + arg.length, 0);
+  if (totalArgLen > ARG_MAX_BYTES) {
+    throw new InvalidError(
+      `Total length of CMD arguments must be less than ${ARG_MAX_BYTES} bytes (ARG_MAX). Got ${totalArgLen} bytes.`
+    );
+  }
+}
+function buildTaskExecStartRequestProto(taskId, execId, command, params) {
   checkForRenamedParams(params, { timeout: "timeoutMs" });
   if (params?.timeoutMs != void 0 && params.timeoutMs <= 0) {
     throw new Error(`timeoutMs must be positive, got ${params.timeoutMs}`);
@@ -47063,17 +48723,39 @@ async function buildContainerExecRequestProto(taskId, command, params) {
     );
   }
   const secretIds = (params?.secrets || []).map((secret) => secret.secretId);
+  const stdout = params?.stdout ?? "pipe";
+  const stderr = params?.stderr ?? "pipe";
+  let stdoutConfig;
+  if (stdout === "pipe") {
+    stdoutConfig = 1 /* TASK_EXEC_STDOUT_CONFIG_PIPE */;
+  } else if (stdout === "ignore") {
+    stdoutConfig = 0 /* TASK_EXEC_STDOUT_CONFIG_DEVNULL */;
+  } else {
+    throw new Error(`Unsupported stdout behavior: ${stdout}`);
+  }
+  let stderrConfig;
+  if (stderr === "pipe") {
+    stderrConfig = 1 /* TASK_EXEC_STDERR_CONFIG_PIPE */;
+  } else if (stderr === "ignore") {
+    stderrConfig = 0 /* TASK_EXEC_STDERR_CONFIG_DEVNULL */;
+  } else {
+    throw new Error(`Unsupported stderr behavior: ${stderr}`);
+  }
   let ptyInfo;
   if (params?.pty) {
     ptyInfo = defaultSandboxPTYInfo();
   }
-  return ContainerExecRequest.create({
+  return TaskExecStartRequest.create({
     taskId,
-    command,
+    execId,
+    commandArgs: command,
+    stdoutConfig,
+    stderrConfig,
+    timeoutSecs: params?.timeoutMs ? params.timeoutMs / 1e3 : void 0,
     workdir: params?.workdir,
-    timeoutSecs: params?.timeoutMs ? params.timeoutMs / 1e3 : 0,
     secretIds,
-    ptyInfo
+    ptyInfo,
+    runtimeDebug: false
   });
 }
 var Sandbox2 = class _Sandbox {
@@ -47086,6 +48768,9 @@ var Sandbox2 = class _Sandbox {
   #stderrAbort;
   #taskId;
   #tunnels;
+  #commandRouterClient;
+  #commandRouterClientPromise;
+  #attached = true;
   /** @ignore */
   constructor(client2, sandboxId) {
     this.#client = client2;
@@ -47137,6 +48822,7 @@ var Sandbox2 = class _Sandbox {
   }
   /** Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in {@link SandboxService#list Sandbox.list}. */
   async setTags(tags) {
+    this.#ensureAttached();
     const tagsList = Object.entries(tags).map(([tagName, tagValue]) => ({
       tagName,
       tagValue
@@ -47148,7 +48834,7 @@ var Sandbox2 = class _Sandbox {
         tags: tagsList
       });
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.INVALID_ARGUMENT) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
         throw new InvalidError(err.details || err.message);
       }
       throw err;
@@ -47156,13 +48842,14 @@ var Sandbox2 = class _Sandbox {
   }
   /** Get tags (key-value pairs) currently attached to this Sandbox from the server. */
   async getTags() {
+    this.#ensureAttached();
     let resp;
     try {
       resp = await this.#client.cpClient.sandboxTagsGet({
         sandboxId: this.sandboxId
       });
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.INVALID_ARGUMENT) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
         throw new InvalidError(err.details || err.message);
       }
       throw err;
@@ -47194,6 +48881,7 @@ var Sandbox2 = class _Sandbox {
    * @returns Promise that resolves to a {@link SandboxFile}
    */
   async open(path2, mode = "r") {
+    this.#ensureAttached();
     const taskId = await this.#getTaskId();
     const resp = await runFilesystemExec(this.#client.cpClient, {
       fileOpenRequest: {
@@ -47206,6 +48894,8 @@ var Sandbox2 = class _Sandbox {
     return new SandboxFile(this.#client, fileDescriptor, taskId);
   }
   async exec(command, params) {
+    this.#ensureAttached();
+    validateExecArgs(command);
     const taskId = await this.#getTaskId();
     const mergedSecrets = await mergeEnvIntoSecrets(
       this.#client,
@@ -47218,22 +48908,37 @@ var Sandbox2 = class _Sandbox {
       env: void 0
       // setting env to undefined just to clarify it's not needed anymore
     };
-    const req = await buildContainerExecRequestProto(
+    const commandRouterClient = await this.#getOrCreateCommandRouterClient(taskId);
+    const execId = (0, import_uuid.v4)();
+    const request = buildTaskExecStartRequestProto(
       taskId,
+      execId,
       command,
       mergedParams
     );
-    const resp = await this.#client.cpClient.containerExec(req);
+    await commandRouterClient.execStart(request);
     this.#client.logger.debug(
       "Created ContainerProcess",
       "exec_id",
-      resp.execId,
+      execId,
       "sandbox_id",
       this.sandboxId,
       "command",
       command
     );
-    return new ContainerProcess(this.#client, resp.execId, params);
+    const deadline = mergedParams?.timeoutMs ? Date.now() + mergedParams.timeoutMs : null;
+    return new ContainerProcess(
+      taskId,
+      execId,
+      commandRouterClient,
+      mergedParams,
+      deadline
+    );
+  }
+  #ensureAttached() {
+    if (!this.#attached) {
+      throw new ClientClosedError();
+    }
   }
   async #getTaskId() {
     if (this.#taskId === void 0) {
@@ -47254,19 +48959,74 @@ var Sandbox2 = class _Sandbox {
     }
     return this.#taskId;
   }
+  async #getOrCreateCommandRouterClient(taskId) {
+    if (this.#commandRouterClient !== void 0) {
+      return this.#commandRouterClient;
+    }
+    if (this.#commandRouterClientPromise !== void 0) {
+      return this.#commandRouterClientPromise;
+    }
+    const promise = (async () => {
+      const client2 = await TaskCommandRouterClientImpl.tryInit(
+        this.#client.cpClient,
+        taskId,
+        this.#client.logger,
+        this.#client.profile
+      );
+      if (!client2) {
+        throw new Error(
+          "Command router access is not available for this sandbox"
+        );
+      }
+      if (!this.#attached) {
+        client2.close();
+        throw new ClientClosedError();
+      }
+      this.#commandRouterClient = client2;
+      return client2;
+    })();
+    this.#commandRouterClientPromise = promise;
+    try {
+      return await promise;
+    } catch (err) {
+      if (this.#commandRouterClientPromise === promise) {
+        this.#commandRouterClientPromise = void 0;
+      }
+      throw err;
+    }
+  }
   /**
    * Create a token for making HTTP connections to the Sandbox.
    */
   async createConnectToken(params) {
+    this.#ensureAttached();
     const resp = await this.#client.cpClient.sandboxCreateConnectToken({
       sandboxId: this.sandboxId,
       userMetadata: params?.userMetadata
     });
     return { url: resp.url, token: resp.token };
   }
-  async terminate() {
+  async terminate(params) {
+    this.#ensureAttached();
     await this.#client.cpClient.sandboxTerminate({ sandboxId: this.sandboxId });
+    let exitCode;
+    if (params?.wait) {
+      exitCode = await this.wait();
+    }
     this.#taskId = void 0;
+    this.detach();
+    return exitCode;
+  }
+  /**
+   * Disconnect from the Sandbox, cleaning up local resources.
+   * The Sandbox continues running on Modal's infrastructure.
+   * After calling detach(), most operations on this Sandbox object will throw.
+   */
+  detach() {
+    this.#commandRouterClient?.close();
+    this.#attached = false;
+    this.#commandRouterClient = void 0;
+    this.#commandRouterClientPromise = void 0;
   }
   async wait() {
     while (true) {
@@ -47296,6 +49056,7 @@ var Sandbox2 = class _Sandbox {
    * @returns A dictionary of {@link Tunnel} objects which are keyed by the container port.
    */
   async tunnels(timeoutMs = 5e4) {
+    this.#ensureAttached();
     if (this.#tunnels) {
       return this.#tunnels;
     }
@@ -47326,6 +49087,7 @@ var Sandbox2 = class _Sandbox {
    * @returns Promise that resolves to an {@link Image}
    */
   async snapshotFilesystem(timeoutMs = 55e3) {
+    this.#ensureAttached();
     const resp = await this.#client.cpClient.sandboxSnapshotFs({
       sandboxId: this.sandboxId,
       timeout: timeoutMs / 1e3
@@ -47340,12 +49102,58 @@ var Sandbox2 = class _Sandbox {
     }
     return new Image2(this.#client, resp.imageId, "");
   }
+  /**
+   * Mount an {@link Image} at a path in the Sandbox filesystem.
+   *
+   * @param path - The path where the directory should be mounted
+   * @param image - Optional {@link Image} to mount. If undefined, mounts an empty directory.
+   */
+  async mountImage(path2, image) {
+    this.#ensureAttached();
+    const taskId = await this.#getTaskId();
+    const commandRouterClient = await this.#getOrCreateCommandRouterClient(taskId);
+    if (image && !image.imageId) {
+      throw new Error(
+        "Image must be built before mounting. Call `image.build(app)` first."
+      );
+    }
+    const pathBytes = new TextEncoder().encode(path2);
+    const imageId = image?.imageId ?? "";
+    const request = TaskMountDirectoryRequest.create({
+      taskId,
+      path: pathBytes,
+      imageId
+    });
+    await commandRouterClient.mountDirectory(request);
+  }
+  /**
+   * Snapshots and creates a new {@link Image} from a directory in the running sandbox.
+   *
+   * @param path - The path of the directory to snapshot
+   * @returns Promise that resolves to an {@link Image}
+   */
+  async snapshotDirectory(path2) {
+    this.#ensureAttached();
+    const taskId = await this.#getTaskId();
+    const commandRouterClient = await this.#getOrCreateCommandRouterClient(taskId);
+    const pathBytes = new TextEncoder().encode(path2);
+    const request = TaskSnapshotDirectoryRequest.create({
+      taskId,
+      path: pathBytes
+    });
+    const response = await commandRouterClient.snapshotDirectory(request);
+    if (!response.imageId) {
+      throw new Error("Sandbox snapshot directory response missing `imageId`");
+    }
+    return new Image2(this.#client, response.imageId, "");
+  }
   /**
    * Check if the Sandbox has finished running.
    *
    * Returns `null` if the Sandbox is still running, else returns the exit code.
    */
   async poll() {
+    this.#ensureAttached();
     const resp = await this.#client.cpClient.sandboxWait({
       sandboxId: this.sandboxId,
       timeout: 0
@@ -47375,38 +49183,40 @@ var ContainerProcess = class {
   stdin;
   stdout;
   stderr;
-  returncode = null;
-  #client;
+  #taskId;
   #execId;
-  constructor(client2, execId, params) {
-    this.#client = client2;
+  #commandRouterClient;
+  #deadline;
+  /** @ignore */
+  constructor(taskId, execId, commandRouterClient, params, deadline) {
+    this.#taskId = taskId;
+    this.#execId = execId;
+    this.#commandRouterClient = commandRouterClient;
+    this.#deadline = deadline ?? null;
     const mode = params?.mode ?? "text";
     const stdout = params?.stdout ?? "pipe";
     const stderr = params?.stderr ?? "pipe";
-    this.#execId = execId;
-    this.stdin = toModalWriteStream(inputStreamCp(client2.cpClient, execId));
-    let stdoutStream = streamConsumingIter(
+    this.stdin = toModalWriteStream(
+      inputStreamCp(commandRouterClient, taskId, execId)
+    );
+    const stdoutStream = stdout === "ignore" ? ReadableStream.from([]) : streamConsumingIter(
       outputStreamCp(
-        client2.cpClient,
+        commandRouterClient,
+        taskId,
         execId,
-        1 /* FILE_DESCRIPTOR_STDOUT */
+        1 /* FILE_DESCRIPTOR_STDOUT */,
+        this.#deadline
       )
     );
-    if (stdout === "ignore") {
-      stdoutStream.cancel();
-      stdoutStream = ReadableStream.from([]);
-    }
-    let stderrStream = streamConsumingIter(
+    const stderrStream = stderr === "ignore" ? ReadableStream.from([]) : streamConsumingIter(
       outputStreamCp(
-        client2.cpClient,
+        commandRouterClient,
+        taskId,
         execId,
-        2 /* FILE_DESCRIPTOR_STDERR */
+        2 /* FILE_DESCRIPTOR_STDERR */,
+        this.#deadline
       )
     );
-    if (stderr === "ignore") {
-      stderrStream.cancel();
-      stderrStream = ReadableStream.from([]);
-    }
     if (mode === "text") {
       this.stdout = toModalReadStream(
         stdoutStream.pipeThrough(new TextDecoderStream())
@@ -47421,14 +49231,17 @@ var ContainerProcess = class {
   }
   /** Wait for process completion and return the exit code. */
   async wait() {
-    while (true) {
-      const resp = await this.#client.cpClient.containerExecWait({
-        execId: this.#execId,
-        timeout: 55
-      });
-      if (resp.completed) {
-        return resp.exitCode ?? 0;
-      }
+    const resp = await this.#commandRouterClient.execWait(
+      this.#taskId,
+      this.#execId,
+      this.#deadline
+    );
+    if (resp.code !== void 0) {
+      return resp.code;
+    } else if (resp.signal !== void 0) {
+      return 128 + resp.signal;
+    } else {
+      throw new InvalidError("Unexpected exit status");
     }
   }
 };
@@ -47464,7 +49277,7 @@ async function* outputStreamSb(cpClient, sandboxId, fileDescriptor, signal) {
       }
       if (isRetryableGrpc(err) && retriesRemaining > 0) {
         try {
-          await (0, import_promises.setTimeout)(delayMs, void 0, { signal });
+          await (0, import_promises2.setTimeout)(delayMs, void 0, { signal });
         } catch {
           return;
         }
@@ -47477,33 +49290,6 @@ async function* outputStreamSb(cpClient, sandboxId, fileDescriptor, signal) {
     }
   }
 }
-async function* outputStreamCp(cpClient, execId, fileDescriptor) {
-  let lastIndex = 0;
-  let completed = false;
-  let retries = 10;
-  while (!completed) {
-    try {
-      const outputIterator = cpClient.containerExecGetOutput({
-        execId,
-        fileDescriptor,
-        timeout: 55,
-        getRawBytes: true,
-        lastBatchIndex: lastIndex
-      });
-      for await (const batch of outputIterator) {
-        lastIndex = batch.batchIndex;
-        yield* batch.items.map((item) => item.messageBytes);
-        if (batch.exitCode !== void 0) {
-          completed = true;
-          break;
-        }
-      }
-    } catch (err) {
-      if (isRetryableGrpc(err) && retries > 0) retries--;
-      else throw err;
-    }
-  }
-}
 function inputStreamSb(cpClient, sandboxId) {
   let index = 1;
   return new WritableStream({
@@ -47524,27 +49310,40 @@ function inputStreamSb(cpClient, sandboxId) {
     }
   });
 }
-function inputStreamCp(cpClient, execId) {
-  let messageIndex = 1;
+async function* outputStreamCp(commandRouterClient, taskId, execId, fileDescriptor, deadline) {
+  for await (const batch of commandRouterClient.execStdioRead(
+    taskId,
+    execId,
+    fileDescriptor,
+    deadline
+  )) {
+    yield batch.data;
+  }
+}
+function inputStreamCp(commandRouterClient, taskId, execId) {
+  let offset = 0;
   return new WritableStream({
     async write(chunk) {
-      await cpClient.containerExecPutInput({
+      const data = encodeIfString(chunk);
+      await commandRouterClient.execStdinWrite(
+        taskId,
         execId,
-        input: {
-          message: encodeIfString(chunk),
-          messageIndex
-        }
-      });
-      messageIndex++;
+        offset,
+        data,
+        false
+        // eof
+      );
+      offset += data.length;
     },
     async close() {
-      await cpClient.containerExecPutInput({
+      await commandRouterClient.execStdinWrite(
+        taskId,
         execId,
-        input: {
-          messageIndex,
-          eof: true
-        }
-      });
+        offset,
+        new Uint8Array(0),
+        true
+        // eof
+      );
     }
   });
 }
@@ -47553,7 +49352,7 @@ function encodeIfString(chunk) {
 }
 
 // src/volume.ts
-var import_nice_grpc9 = require("nice-grpc");
+var import_nice_grpc10 = require("nice-grpc");
 var VolumeService = class {
   #client;
   constructor(client2) {
@@ -47578,7 +49377,7 @@ var VolumeService = class {
       );
       return new Volume(resp.volumeId, name);
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc10.ClientError && err.code === import_nice_grpc10.Status.NOT_FOUND)
         throw new NotFoundError(err.details);
       throw err;
     }
@@ -47624,7 +49423,7 @@ var VolumeService = class {
         volume.volumeId
       );
     } catch (err) {
-      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND;
+      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc10.ClientError && err.code === import_nice_grpc10.Status.NOT_FOUND;
       if (isNotFound && params?.allowMissing) {
         return;
       }
@@ -47673,54 +49472,6 @@ var Volume = class _Volume {
   }
 };
 
-// src/config.ts
-var import_node_fs = require("fs");
-var import_node_os = require("os");
-var import_node_path = __toESM(require("path"), 1);
-var import_smol_toml = require("smol-toml");
-function configFilePath() {
-  const configPath = process.env["MODAL_CONFIG_PATH"];
-  if (configPath && configPath !== "") {
-    return configPath;
-  }
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".modal.toml");
-}
-function readConfigFile() {
-  try {
-    const configPath = configFilePath();
-    const configContent = (0, import_node_fs.readFileSync)(configPath, {
-      encoding: "utf-8"
-    });
-    return (0, import_smol_toml.parse)(configContent);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return {};
-    }
-    return {};
-  }
-}
-var config = readConfigFile();
-function getProfile(profileName) {
-  if (!profileName) {
-    for (const [name, profileData2] of Object.entries(config)) {
-      if (profileData2.active) {
-        profileName = name;
-        break;
-      }
-    }
-  }
-  const profileData = profileName && Object.hasOwn(config, profileName) ? config[profileName] : {};
-  const profile = {
-    serverUrl: process.env["MODAL_SERVER_URL"] || profileData.server_url || "https://api.modal.com:443",
-    tokenId: process.env["MODAL_TOKEN_ID"] || profileData.token_id,
-    tokenSecret: process.env["MODAL_TOKEN_SECRET"] || profileData.token_secret,
-    environment: process.env["MODAL_ENVIRONMENT"] || profileData.environment,
-    imageBuilderVersion: process.env["MODAL_IMAGE_BUILDER_VERSION"] || profileData.imageBuilderVersion,
-    logLevel: process.env["MODAL_LOGLEVEL"] || profileData.loglevel
-  };
-  return profile;
-}
-
 // src/auth_token_manager.ts
 var REFRESH_WINDOW = 5 * 60;
 var DEFAULT_EXPIRY_OFFSET = 20 * 60;
@@ -47879,7 +49630,7 @@ var AuthTokenManager = class {
 
 // src/version.ts
 function getSDKVersion() {
-  return true ? "0.6.3" : "0.0.0";
+  return true ? "0.7.1" : "0.0.0";
 }
 
 // src/logger.ts
@@ -48072,7 +49823,7 @@ var ModalClient2 = class {
     return getSDKVersion();
   }
   createClient(profile) {
-    const channel = (0, import_nice_grpc10.createChannel)(profile.serverUrl, void 0, {
+    const channel = (0, import_nice_grpc11.createChannel)(profile.serverUrl, void 0, {
       "grpc.max_receive_message_length": 100 * 1024 * 1024,
       "grpc.max_send_message_length": 100 * 1024 * 1024,
       "grpc-node.flow_control_window": 64 * 1024 * 1024,
@@ -48080,7 +49831,7 @@ var ModalClient2 = class {
       "grpc.keepalive_timeout_ms": 1e4,
       "grpc.keepalive_permit_without_calls": 1
     });
-    let factory = (0, import_nice_grpc10.createClientFactory)().use(this.authMiddleware(profile)).use(this.retryMiddleware()).use(timeoutMiddleware);
+    let factory = (0, import_nice_grpc11.createClientFactory)().use(this.authMiddleware(profile)).use(this.retryMiddleware()).use(timeoutMiddleware);
     for (const middleware of this.customMiddleware) {
       factory = factory.use(middleware);
     }
@@ -48106,13 +49857,13 @@ var ModalClient2 = class {
         ...retryableGrpcStatusCodes,
         ...additionalStatusCodes
       ]);
-      const idempotencyKey = (0, import_uuid.v4)();
+      const idempotencyKey = (0, import_uuid2.v4)();
       const startTime = Date.now();
       let attempt = 0;
       let delayMs = baseDelay;
       logger.debug("Sending gRPC request", "method", call.method.path);
       while (true) {
-        const metadata = new import_nice_grpc10.Metadata(restOptions.metadata ?? {});
+        const metadata = new import_nice_grpc11.Metadata(restOptions.metadata ?? {});
         metadata.set("x-idempotency-key", idempotencyKey);
         metadata.set("x-retry-attempt", String(attempt));
         if (attempt > 0) {
@@ -48128,7 +49879,7 @@ var ModalClient2 = class {
             signal
           });
         } catch (err) {
-          if (!(err instanceof import_nice_grpc10.ClientError) || !retryableCodes.has(err.code) || attempt >= retries) {
+          if (!(err instanceof import_nice_grpc11.ClientError) || !retryableCodes.has(err.code) || attempt >= retries) {
             if (attempt === retries && attempt > 0) {
               logger.debug(
                 "Final retry attempt failed",
@@ -48186,7 +49937,7 @@ var ModalClient2 = class {
         );
       }
       const { tokenId, tokenSecret } = profile;
-      options.metadata ??= new import_nice_grpc10.Metadata();
+      options.metadata ??= new import_nice_grpc11.Metadata();
       options.metadata.set(
         "x-modal-client-type",
         String(8 /* CLIENT_TYPE_LIBMODAL_JS */)
@@ -48231,23 +49982,23 @@ var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
     origSignal?.removeEventListener("abort", abortListener);
     clearTimeout(timer);
     if (timedOut) {
-      throw new import_nice_grpc10.ClientError(
+      throw new import_nice_grpc11.ClientError(
         call.method.path,
-        import_nice_grpc10.Status.DEADLINE_EXCEEDED,
+        import_nice_grpc11.Status.DEADLINE_EXCEEDED,
         `Timed out after ${timeoutMs}ms`
       );
     }
   }
 };
 var retryableGrpcStatusCodes = /* @__PURE__ */ new Set([
-  import_nice_grpc10.Status.DEADLINE_EXCEEDED,
-  import_nice_grpc10.Status.UNAVAILABLE,
-  import_nice_grpc10.Status.CANCELLED,
-  import_nice_grpc10.Status.INTERNAL,
-  import_nice_grpc10.Status.UNKNOWN
+  import_nice_grpc11.Status.DEADLINE_EXCEEDED,
+  import_nice_grpc11.Status.UNAVAILABLE,
+  import_nice_grpc11.Status.CANCELLED,
+  import_nice_grpc11.Status.INTERNAL,
+  import_nice_grpc11.Status.UNKNOWN
 ]);
 function isRetryableGrpc(err) {
-  if (err instanceof import_nice_grpc10.ClientError) {
+  if (err instanceof import_nice_grpc11.ClientError) {
     return retryableGrpcStatusCodes.has(err.code);
   }
   return false;
@@ -48316,7 +50067,7 @@ var AppService = class {
       );
       return new App2(resp.appId, name);
     } catch (err) {
-      if (err instanceof import_nice_grpc11.ClientError && err.code === import_nice_grpc11.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.NOT_FOUND)
         throw new NotFoundError(`App '${name}' not found`);
       throw err;
     }
@@ -48388,6 +50139,7 @@ var App2 = class {
   AlreadyExistsError,
   App,
   AppService,
+  ClientClosedError,
   CloudBucketMount,
   CloudBucketMountService,
   Cls,