modal 0.3.7 → 0.3.9

package/dist/index.js

@@ -37797,13 +37797,13 @@ import {
 } from "nice-grpc";
 
 // src/config.ts
-import { readFile } from "node:fs/promises";
-import path from "node:path";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import path from "node:path";
 import { parse as parseToml } from "smol-toml";
-async function readConfigFile() {
+function readConfigFile() {
   try {
-    const configContent = await readFile(path.join(homedir(), ".modal.toml"), {
+    const configContent = readFileSync(path.join(homedir(), ".modal.toml"), {
       encoding: "utf-8"
     });
     return parseToml(configContent);
@@ -37814,7 +37814,7 @@ async function readConfigFile() {
     throw new Error(`Failed to read or parse .modal.toml: ${err.message}`);
   }
 }
-var config = await readConfigFile();
+var config = readConfigFile();
 function getProfile(profileName) {
   profileName = profileName || process.env["MODAL_PROFILE"] || void 0;
   if (!profileName) {
@@ -38040,6 +38040,156 @@ ${result.exception}`
   return new Image2(resp.imageId);
 }
 
+// src/errors.ts
+var FunctionTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FunctionTimeoutError";
+  }
+};
+var RemoteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RemoteError";
+  }
+};
+var InternalFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InternalFailure";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+var InvalidError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidError";
+  }
+};
+var QueueEmptyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QueueEmptyError";
+  }
+};
+var QueueFullError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QueueFullError";
+  }
+};
+var SandboxFilesystemError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemError";
+  }
+};
+
+// src/sandbox_filesystem.ts
+var SandboxFile = class {
+  #fileDescriptor;
+  #taskId;
+  /** @ignore */
+  constructor(fileDescriptor, taskId) {
+    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({
+      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({
+      fileWriteRequest: {
+        fileDescriptor: this.#fileDescriptor,
+        data
+      },
+      taskId: this.#taskId
+    });
+  }
+  /**
+   * Flush any buffered data to the file.
+   */
+  async flush() {
+    await runFilesystemExec({
+      fileFlushRequest: {
+        fileDescriptor: this.#fileDescriptor
+      },
+      taskId: this.#taskId
+    });
+  }
+  /**
+   * Close the file handle.
+   */
+  async close() {
+    await runFilesystemExec({
+      fileCloseRequest: {
+        fileDescriptor: this.#fileDescriptor
+      },
+      taskId: this.#taskId
+    });
+  }
+};
+async function runFilesystemExec(request) {
+  const response = await client.containerFilesystemExec(request);
+  const chunks = [];
+  let retries = 10;
+  let completed = false;
+  while (!completed) {
+    try {
+      const outputIterator = client.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);
@@ -38172,28 +38322,50 @@ var Sandbox2 = class {
       ).pipeThrough(new TextDecoderStream())
     );
   }
+  /**
+   * Open a file in the sandbox filesystem.
+   * @param path - Path to the file to open
+   * @param mode - File open mode (r, w, a, r+, w+, a+)
+   * @returns Promise that resolves to a SandboxFile
+   */
+  async open(path2, mode = "r") {
+    const taskId = await this.#getTaskId();
+    const resp = await runFilesystemExec({
+      fileOpenRequest: {
+        path: path2,
+        mode
+      },
+      taskId
+    });
+    const fileDescriptor = resp.response.fileDescriptor;
+    return new SandboxFile(fileDescriptor, taskId);
+  }
   async exec(command, options) {
+    const taskId = await this.#getTaskId();
+    const resp = await client.containerExec({
+      taskId,
+      command
+    });
+    return new ContainerProcess(resp.execId, options);
+  }
+  async #getTaskId() {
     if (this.#taskId === void 0) {
-      const resp2 = await client.sandboxGetTaskId({
+      const resp = await client.sandboxGetTaskId({
         sandboxId: this.sandboxId
       });
-      if (!resp2.taskId) {
+      if (!resp.taskId) {
         throw new Error(
           `Sandbox ${this.sandboxId} does not have a task ID. It may not be running.`
         );
       }
-      if (resp2.taskResult) {
+      if (resp.taskResult) {
         throw new Error(
-          `Sandbox ${this.sandboxId} has already completed with result: ${resp2.taskResult}`
+          `Sandbox ${this.sandboxId} has already completed with result: ${resp.taskResult}`
         );
       }
-      this.#taskId = resp2.taskId;
+      this.#taskId = resp.taskId;
     }
-    const resp = await client.containerExec({
-      taskId: this.#taskId,
-      command
-    });
-    return new ContainerProcess(resp.execId, options);
+    return this.#taskId;
   }
   async terminate() {
     await client.sandboxTerminate({ sandboxId: this.sandboxId });
@@ -38363,50 +38535,6 @@ function encodeIfString(chunk) {
   return typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
 }
 
-// src/errors.ts
-var FunctionTimeoutError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FunctionTimeoutError";
-  }
-};
-var RemoteError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RemoteError";
-  }
-};
-var InternalFailure = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InternalFailure";
-  }
-};
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NotFoundError";
-  }
-};
-var InvalidError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidError";
-  }
-};
-var QueueEmptyError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QueueEmptyError";
-  }
-};
-var QueueFullError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QueueFullError";
-  }
-};
-
 // src/secret.ts
 import { ClientError as ClientError2, Status as Status2 } from "nice-grpc";
 var Secret = class _Secret {
@@ -38505,31 +38633,6 @@ import { ClientError as ClientError5, Status as Status5 } from "nice-grpc";
 // src/function.ts
 import { createHash } from "node:crypto";
 
-// src/function_call.ts
-var FunctionCall = class _FunctionCall {
-  functionCallId;
-  /** @ignore */
-  constructor(functionCallId) {
-    this.functionCallId = functionCallId;
-  }
-  /** Create a new function call from ID. */
-  fromId(functionCallId) {
-    return new _FunctionCall(functionCallId);
-  }
-  /** Get the result of a function call, optionally waiting with a timeout. */
-  async get(options = {}) {
-    const timeout = options.timeout;
-    return await pollFunctionOutput(this.functionCallId, timeout);
-  }
-  /** Cancel a running function call. */
-  async cancel(options = {}) {
-    await client.functionCallCancel({
-      functionCallId: this.functionCallId,
-      terminateContainers: options.terminateContainers
-    });
-  }
-};
-
 // src/pickle.ts
 var PickleError = class extends Error {
   constructor(message) {
@@ -38877,79 +38980,62 @@ function loads(buf) {
   throw new PickleError("pickle stream ended without STOP");
 }
 
-// src/function.ts
-import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
-var maxObjectSizeBytes = 2 * 1024 * 1024;
+// src/invocation.ts
 var outputsTimeout = 55 * 1e3;
-function timeNowSeconds() {
-  return Date.now() / 1e3;
-}
-var Function_ = class _Function_ {
-  functionId;
-  methodName;
-  /** @ignore */
-  constructor(functionId, methodName) {
-    this.functionId = functionId;
-    this.methodName = methodName;
-  }
-  static async lookup(appName, name, options = {}) {
-    try {
-      const resp = await client.functionGet({
-        appName,
-        objectTag: name,
-        namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
-        environmentName: environmentName(options.environment)
-      });
-      return new _Function_(resp.functionId);
-    } catch (err) {
-      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
-        throw new NotFoundError(`Function '${appName}/${name}' not found`);
-      throw err;
-    }
+var ControlPlaneInvocation = class _ControlPlaneInvocation {
+  functionCallId;
+  input;
+  functionCallJwt;
+  inputJwt;
+  constructor(functionCallId, input, functionCallJwt, inputJwt) {
+    this.functionCallId = functionCallId;
+    this.input = input;
+    this.functionCallJwt = functionCallJwt;
+    this.inputJwt = inputJwt;
   }
-  // Execute a single input into a remote Function.
-  async remote(args = [], kwargs = {}) {
-    const functionCallId = await this.#execFunctionCall(
-      args,
-      kwargs,
-      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
+  static async create(functionId, input, invocationType) {
+    const functionPutInputsItem = {
+      idx: 0,
+      input
+    };
+    const functionMapResponse = await client.functionMap({
+      functionId,
+      functionCallType: 1 /* FUNCTION_CALL_TYPE_UNARY */,
+      functionCallInvocationType: invocationType,
+      pipelinedInputs: [functionPutInputsItem]
+    });
+    return new _ControlPlaneInvocation(
+      functionMapResponse.functionCallId,
+      input,
+      functionMapResponse.functionCallJwt,
+      functionMapResponse.pipelinedInputs[0].inputJwt
     );
-    return await pollFunctionOutput(functionCallId);
   }
-  // Spawn a single input into a remote function.
-  async spawn(args = [], kwargs = {}) {
-    const functionCallId = await this.#execFunctionCall(
-      args,
-      kwargs,
-      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
-    );
-    return new FunctionCall(functionCallId);
+  static fromFunctionCallId(functionCallId) {
+    return new _ControlPlaneInvocation(functionCallId);
   }
-  async #execFunctionCall(args = [], kwargs = {}, invocationType = 4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */) {
-    const payload = dumps([args, kwargs]);
-    let argsBlobId = void 0;
-    if (payload.length > maxObjectSizeBytes) {
-      argsBlobId = await blobUpload(payload);
+  async awaitOutput(timeout) {
+    return await pollFunctionOutput(this.functionCallId, timeout);
+  }
+  async retry(retryCount) {
+    if (!this.input) {
+      throw new Error("Cannot retry function invocation - input missing");
     }
-    const functionMapResponse = await client.functionMap({
-      functionId: this.functionId,
-      functionCallType: 1 /* FUNCTION_CALL_TYPE_UNARY */,
-      functionCallInvocationType: invocationType,
-      pipelinedInputs: [
-        {
-          idx: 0,
-          input: {
-            args: argsBlobId ? void 0 : payload,
-            argsBlobId,
-            dataFormat: 1 /* DATA_FORMAT_PICKLE */,
-            methodName: this.methodName
-          }
-        }
-      ]
+    const retryItem = {
+      inputJwt: this.inputJwt,
+      input: this.input,
+      retryCount
+    };
+    const functionRetryResponse = await client.functionRetryInputs({
+      functionCallJwt: this.functionCallJwt,
+      inputs: [retryItem]
     });
-    return functionMapResponse.functionCallId;
+    this.inputJwt = functionRetryResponse.inputJwts[0];
   }
 };
+function timeNowSeconds() {
+  return Date.now() / 1e3;
+}
 async function pollFunctionOutput(functionCallId, timeout) {
   const startTime = Date.now();
   let pollTimeout = outputsTimeout;
@@ -39007,6 +39093,134 @@ async function processResult(result, dataFormat) {
   }
   return deserializeDataFormat(data, dataFormat);
 }
+async function blobDownload(blobId) {
+  const resp = await client.blobGet({ blobId });
+  const s3resp = await fetch(resp.downloadUrl);
+  if (!s3resp.ok) {
+    throw new Error(`Failed to download blob: ${s3resp.statusText}`);
+  }
+  const buf = await s3resp.arrayBuffer();
+  return new Uint8Array(buf);
+}
+function deserializeDataFormat(data, dataFormat) {
+  if (!data) {
+    return null;
+  }
+  switch (dataFormat) {
+    case 1 /* DATA_FORMAT_PICKLE */:
+      return loads(data);
+    case 2 /* DATA_FORMAT_ASGI */:
+      throw new Error("ASGI data format is not supported in Go");
+    case 3 /* DATA_FORMAT_GENERATOR_DONE */:
+      return GeneratorDone.decode(data);
+    default:
+      throw new Error(`Unsupported data format: ${dataFormat}`);
+  }
+}
+
+// src/function_call.ts
+var FunctionCall = class _FunctionCall {
+  functionCallId;
+  /** @ignore */
+  constructor(functionCallId) {
+    this.functionCallId = functionCallId;
+  }
+  /** Create a new function call from ID. */
+  fromId(functionCallId) {
+    return new _FunctionCall(functionCallId);
+  }
+  /** Get the result of a function call, optionally waiting with a timeout. */
+  async get(options = {}) {
+    const timeout = options.timeout;
+    const invocation = ControlPlaneInvocation.fromFunctionCallId(
+      this.functionCallId
+    );
+    return invocation.awaitOutput(timeout);
+  }
+  /** Cancel a running function call. */
+  async cancel(options = {}) {
+    await client.functionCallCancel({
+      functionCallId: this.functionCallId,
+      terminateContainers: options.terminateContainers
+    });
+  }
+};
+
+// src/function.ts
+import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
+var maxObjectSizeBytes = 2 * 1024 * 1024;
+var maxSystemRetries = 8;
+var Function_ = class _Function_ {
+  functionId;
+  methodName;
+  /** @ignore */
+  constructor(functionId, methodName) {
+    this.functionId = functionId;
+    this.methodName = methodName;
+  }
+  static async lookup(appName, name, options = {}) {
+    try {
+      const resp = await client.functionGet({
+        appName,
+        objectTag: name,
+        namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
+        environmentName: environmentName(options.environment)
+      });
+      return new _Function_(resp.functionId);
+    } catch (err) {
+      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
+        throw new NotFoundError(`Function '${appName}/${name}' not found`);
+      throw err;
+    }
+  }
+  // Execute a single input into a remote Function.
+  async remote(args = [], kwargs = {}) {
+    const input = await this.#createInput(args, kwargs);
+    const invocation = await ControlPlaneInvocation.create(
+      this.functionId,
+      input,
+      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
+    );
+    let retryCount = 0;
+    while (true) {
+      try {
+        return await invocation.awaitOutput();
+      } catch (err) {
+        if (err instanceof InternalFailure && retryCount <= maxSystemRetries) {
+          await invocation.retry(retryCount);
+          retryCount++;
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  // Spawn a single input into a remote function.
+  async spawn(args = [], kwargs = {}) {
+    const input = await this.#createInput(args, kwargs);
+    const invocation = await ControlPlaneInvocation.create(
+      this.functionId,
+      input,
+      3 /* FUNCTION_CALL_INVOCATION_TYPE_ASYNC */
+    );
+    return new FunctionCall(invocation.functionCallId);
+  }
+  async #createInput(args = [], kwargs = {}) {
+    const payload = dumps([args, kwargs]);
+    let argsBlobId = void 0;
+    if (payload.length > maxObjectSizeBytes) {
+      argsBlobId = await blobUpload(payload);
+    }
+    return {
+      args: argsBlobId ? void 0 : payload,
+      argsBlobId,
+      dataFormat: 1 /* DATA_FORMAT_PICKLE */,
+      methodName: this.methodName,
+      finalInput: false
+      // This field isn't specified in the Python client, so it defaults to false.
+    };
+  }
+};
 async function blobUpload(data) {
   const contentMd5 = createHash("md5").update(data).digest("base64");
   const contentSha256 = createHash("sha256").update(data).digest("base64");
@@ -39036,30 +39250,6 @@ async function blobUpload(data) {
     throw new Error("Missing upload URL in BlobCreate response");
   }
 }
-async function blobDownload(blobId) {
-  const resp = await client.blobGet({ blobId });
-  const s3resp = await fetch(resp.downloadUrl);
-  if (!s3resp.ok) {
-    throw new Error(`Failed to download blob: ${s3resp.statusText}`);
-  }
-  const buf = await s3resp.arrayBuffer();
-  return new Uint8Array(buf);
-}
-function deserializeDataFormat(data, dataFormat) {
-  if (!data) {
-    return null;
-  }
-  switch (dataFormat) {
-    case 1 /* DATA_FORMAT_PICKLE */:
-      return loads(data);
-    case 2 /* DATA_FORMAT_ASGI */:
-      throw new Error("ASGI data format is not supported in Go");
-    case 3 /* DATA_FORMAT_GENERATOR_DONE */:
-      return GeneratorDone.decode(data);
-    default:
-      throw new Error(`Unsupported data format: ${dataFormat}`);
-  }
-}
 
 // src/cls.ts
 var Cls = class _Cls {
@@ -39461,5 +39651,6 @@ export {
   QueueFullError,
   RemoteError,
   Sandbox2 as Sandbox,
+  SandboxFile,
   Secret
 };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "modal",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Modal client library for JavaScript",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "homepage": "https://modal.com/docs",
   "repository": "github:modal-labs/libmodal",
   "bugs": "https://github.com/modal-labs/libmodal/issues",