modal 0.3.6 → 0.3.8

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/app.ts
-import { ClientError as ClientError2, Status as Status2 } from "nice-grpc";
+import { ClientError as ClientError3, Status as Status3 } from "nice-grpc";
 
 // node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
 function varint64read() {
@@ -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) {
@@ -37835,7 +37835,8 @@ function getProfile(profileName) {
     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
+    environment: process.env["MODAL_ENVIRONMENT"] || profileData.environment,
+    imageBuilderVersion: process.env["MODAL_IMAGE_BUILDER_VERSION"] || profileData.imageBuilderVersion
   };
   if (!profile2.tokenId || !profile2.tokenSecret) {
     throw new Error(
@@ -37848,6 +37849,9 @@ var profile = getProfile(process.env["MODAL_PROFILE"] || void 0);
 function environmentName(environment) {
   return environment || profile.environment || "";
 }
+function imageBuilderVersion(version) {
+  return version || profile.imageBuilderVersion || "2024.10";
+}
 
 // src/client.ts
 function authMiddleware(profile2) {
@@ -37980,15 +37984,15 @@ var Image2 = class {
     this.imageId = imageId;
   }
 };
-async function fromRegistryInternal(appId, tag) {
+async function fromRegistryInternal(appId, tag, imageRegistryConfig) {
   const resp = await client.imageGetOrCreate({
     appId,
     image: {
-      dockerfileCommands: [`FROM ${tag}`]
+      dockerfileCommands: [`FROM ${tag}`],
+      imageRegistryConfig
     },
     namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
-    builderVersion: "2024.10"
-    // TODO: make this configurable
+    builderVersion: imageBuilderVersion()
   });
   let result;
   let metadata = void 0;
@@ -38403,6 +38407,34 @@ var QueueFullError = class extends Error {
   }
 };
 
+// src/secret.ts
+import { ClientError as ClientError2, Status as Status2 } from "nice-grpc";
+var Secret = class _Secret {
+  secretId;
+  /** @ignore */
+  constructor(secretId) {
+    this.secretId = secretId;
+  }
+  /** Reference a Secret by its name. */
+  static async fromName(name, options) {
+    try {
+      const resp = await client.secretGetOrCreate({
+        deploymentName: name,
+        namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
+        environmentName: environmentName(options?.environment),
+        requiredKeys: options?.requiredKeys ?? []
+      });
+      return new _Secret(resp.secretId);
+    } catch (err) {
+      if (err instanceof ClientError2 && err.code === Status2.NOT_FOUND)
+        throw new NotFoundError(err.details);
+      if (err instanceof ClientError2 && err.code === Status2.FAILED_PRECONDITION && err.details.includes("Secret is missing key"))
+        throw new NotFoundError(err.details);
+      throw err;
+    }
+  }
+};
+
 // src/app.ts
 var App = class _App {
   appId;
@@ -38420,7 +38452,7 @@ var App = class _App {
       });
       return new _App(resp.appId);
     } catch (err) {
-      if (err instanceof ClientError2 && err.code === Status2.NOT_FOUND)
+      if (err instanceof ClientError3 && err.code === Status3.NOT_FOUND)
         throw new NotFoundError(`App '${name}' not found`);
       throw err;
     }
@@ -38453,39 +38485,26 @@ var App = class _App {
   async imageFromRegistry(tag) {
     return await fromRegistryInternal(this.appId, tag);
   }
+  async imageFromAwsEcr(tag, secret) {
+    if (!(secret instanceof Secret)) {
+      throw new TypeError(
+        "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
+      );
+    }
+    const imageRegistryConfig = {
+      registryAuthType: 1 /* REGISTRY_AUTH_TYPE_AWS */,
+      secretId: secret.secretId
+    };
+    return await fromRegistryInternal(this.appId, tag, imageRegistryConfig);
+  }
 };
 
 // src/cls.ts
-import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
+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) {
@@ -38548,6 +38567,15 @@ var Reader = class {
     const hi = this.uint32LE() >>> 0;
     return hi * 2 ** 32 + lo;
   }
+  int32LE() {
+    const v = new DataView(
+      this.buf.buffer,
+      this.buf.byteOffset + this.pos,
+      4
+    ).getInt32(0, true);
+    this.pos += 4;
+    return v;
+  }
   float64BE() {
     const v = new DataView(
       this.buf.buffer,
@@ -38680,6 +38708,7 @@ function loads(buf) {
     const size = r.uint64LE();
     void size;
   }
+  const MARK = Symbol("pickle-mark");
   while (!r.eof()) {
     const op = r.byte();
     switch (op) {
@@ -38704,8 +38733,7 @@ function loads(buf) {
         break;
       }
       case 74 /* BININT4 */: {
-        const n = r.uint32LE();
-        push(n >>> 31 ? n - 4294967296 : n);
+        push(r.int32LE());
         break;
       }
       case 71 /* BINFLOAT */:
@@ -38780,6 +38808,43 @@ function loads(buf) {
         const _size = r.uint64LE();
         break;
       }
+      case 40 /* MARK */:
+        push(MARK);
+        break;
+      case 101 /* APPENDS */: {
+        const markIndex = stack.lastIndexOf(MARK);
+        if (markIndex === -1) {
+          throw new PickleError("APPENDS without MARK");
+        }
+        const lst = stack[markIndex - 1];
+        if (!Array.isArray(lst)) {
+          throw new PickleError("APPENDS expects a list below MARK");
+        }
+        const items = stack.slice(markIndex + 1);
+        lst.push(...items);
+        stack.length = markIndex - 1;
+        push(lst);
+        break;
+      }
+      case 117 /* SETITEMS */: {
+        const markIndex = stack.lastIndexOf(MARK);
+        if (markIndex === -1) {
+          throw new PickleError("SETITEMS without MARK");
+        }
+        const d = stack[markIndex - 1];
+        if (typeof d !== "object" || d === null || Array.isArray(d)) {
+          throw new PickleError("SETITEMS expects a dict below MARK");
+        }
+        const items = stack.slice(markIndex + 1);
+        for (let i = 0; i < items.length; i += 2) {
+          if (i + 1 < items.length) {
+            d[items[i]] = items[i + 1];
+          }
+        }
+        stack.length = markIndex - 1;
+        push(d);
+        break;
+      }
       default:
         throw new PickleError(`Unsupported opcode 0x${op.toString(16)}`);
     }
@@ -38787,79 +38852,62 @@ function loads(buf) {
   throw new PickleError("pickle stream ended without STOP");
 }
 
-// src/function.ts
-import { ClientError as ClientError3, Status as Status3 } 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 ClientError3 && err.code === Status3.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;
@@ -38917,6 +38965,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");
@@ -38946,30 +39122,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 {
@@ -39010,7 +39162,7 @@ var Cls = class _Cls {
       }
       return new _Cls(serviceFunction.functionId, schema, methodNames);
     } catch (err) {
-      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
+      if (err instanceof ClientError5 && err.code === Status5.NOT_FOUND)
         throw new NotFoundError(`Class '${appName}/${name}' not found`);
       throw err;
     }
@@ -39109,7 +39261,7 @@ var ClsInstance = class {
 };
 
 // src/queue.ts
-import { ClientError as ClientError5, Status as Status5 } from "nice-grpc";
+import { ClientError as ClientError6, Status as Status6 } from "nice-grpc";
 var ephemeralObjectHeartbeatSleep = 3e5;
 var queueInitialPutBackoff = 100;
 var queueDefaultPartitionTtl = 24 * 3600 * 1e3;
@@ -39264,7 +39416,7 @@ var Queue = class _Queue {
         });
         break;
       } catch (e) {
-        if (e instanceof ClientError5 && e.code === Status5.RESOURCE_EXHAUSTED) {
+        if (e instanceof ClientError6 && e.code === Status6.RESOURCE_EXHAUSTED) {
           delay = Math.min(delay * 2, 3e4);
           if (deadline !== void 0) {
             const remaining = deadline - Date.now();
@@ -39370,5 +39522,6 @@ export {
   QueueEmptyError,
   QueueFullError,
   RemoteError,
-  Sandbox2 as Sandbox
+  Sandbox2 as Sandbox,
+  Secret
 };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "modal",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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",
@@ -29,7 +29,10 @@
     "format:check": "prettier --check .",
     "lint": "eslint",
     "prepare": "scripts/gen-proto.sh",
-    "test": "vitest"
+    "test": "vitest",
+    "preversion": "(git update-index --really-refresh && git diff-index --quiet HEAD) || (echo 'You must commit all changes before running npm version' && exit 1)",
+    "version": "npm run build && git add package.json package-lock.json && git commit -m \"modal-js/v$npm_package_version\" && git tag modal-js/v$npm_package_version",
+    "postversion": "git push && git push --tags && npm publish"
   },
   "dependencies": {
     "long": "^5.3.1",