@trigger.dev/core 3.0.0-beta.33 → 3.0.0-beta.35

package/dist/v3/workers/index.mjs

@@ -9,6 +9,8 @@ import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from '@op
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { z } from 'zod';
 import { fromZodError } from 'zod-validation-error';
+import { FormDataEncoder } from 'form-data-encoder';
+import { Readable } from 'node:stream';
 import { PreciseDate } from '@google-cloud/precise-date';
 import util from 'node:util';
 
@@ -349,6 +351,9 @@ function getEnvVar(name) {
 }
 __name(getEnvVar, "getEnvVar");
 
+// package.json
+var version = "3.0.0-beta.35";
+
 // src/v3/otel/tracingSDK.ts
 var _a;
 var AsyncResourceDetector = (_a = class {
@@ -386,7 +391,8 @@ var _TracingSDK = class _TracingSDK {
       ]
     }).merge(new Resource({
       [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
-      [SemanticInternalAttributes.TRIGGER]: true
+      [SemanticInternalAttributes.TRIGGER]: true,
+      [SemanticInternalAttributes.CLI_VERSION]: version
     })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
     const traceProvider = new NodeTracerProvider({
       forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
@@ -516,6 +522,7 @@ var TaskRunErrorCodes = {
   TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
   TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
   TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
   TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
   TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
   HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
@@ -531,10 +538,12 @@ var TaskRunInternalError = z.object({
     "TASK_EXECUTION_FAILED",
     "TASK_EXECUTION_ABORTED",
     "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_PROCESS_SIGKILL_TIMEOUT",
     "TASK_RUN_CANCELLED",
     "TASK_OUTPUT_ERROR",
     "HANDLE_ERROR_ERROR",
-    "GRACEFUL_EXIT_TIMEOUT"
+    "GRACEFUL_EXIT_TIMEOUT",
+    "TASK_RUN_HEARTBEAT_TIMEOUT"
   ]),
   message: z.string().optional()
 });
@@ -837,6 +846,13 @@ z.enum([
   "WAIT_FOR_TASK",
   "WAIT_FOR_BATCH"
 ]);
+z.object({
+  runId: z.string(),
+  messageId: z.string(),
+  isTest: z.boolean(),
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
 
 // src/v3/schemas/resources.ts
 var TaskResource = z.object({
@@ -886,7 +902,8 @@ z.object({
 });
 z.object({
   localOnly: z.boolean(),
-  metadata: BackgroundWorkerMetadata
+  metadata: BackgroundWorkerMetadata,
+  supportsLazyAttempts: z.boolean().optional()
 });
 z.object({
   id: z.string(),
@@ -1114,6 +1131,28 @@ var RetrieveRunResponse = z.object({
     completedAt: z.coerce.date().optional()
   }).optional())
 });
+z.object({
+  name: z.string(),
+  value: z.string()
+});
+z.object({
+  value: z.string()
+});
+z.object({
+  variables: z.record(z.string()),
+  override: z.boolean().optional()
+});
+var EnvironmentVariableResponseBody = z.object({
+  success: z.boolean()
+});
+var EnvironmentVariableValue = z.object({
+  value: z.string()
+});
+var EnvironmentVariable = z.object({
+  name: z.string(),
+  value: z.string()
+});
+var EnvironmentVariables = z.array(EnvironmentVariable);
 
 // src/v3/apiErrors.ts
 var _APIError = class _APIError extends Error {
@@ -1275,8 +1314,6 @@ function calculateNextRetryDelay(options, attempt) {
   return Math.round(timeout);
 }
 __name(calculateNextRetryDelay, "calculateNextRetryDelay");
-
-// src/v3/zodfetch.ts
 var defaultRetryOptions2 = {
   maxAttempts: 3,
   factor: 2,
@@ -1288,6 +1325,32 @@ async function zodfetch(schema, url, requestInit, options) {
   return await _doZodFetch(schema, url, requestInit, options);
 }
 __name(zodfetch, "zodfetch");
+async function zodupload(schema, url, body, requestInit, options) {
+  const form = await createForm(body);
+  const encoder = new FormDataEncoder(form);
+  const finalHeaders = {};
+  for (const [key, value] of Object.entries(requestInit?.headers || {})) {
+    finalHeaders[key] = value;
+  }
+  for (const [key, value] of Object.entries(encoder.headers)) {
+    finalHeaders[key] = value;
+  }
+  finalHeaders["Content-Length"] = String(encoder.contentLength);
+  const finalRequestInit = {
+    ...requestInit,
+    headers: finalHeaders,
+    body: Readable.from(encoder),
+    // @ts-expect-error
+    duplex: "half"
+  };
+  return await _doZodFetch(schema, url, finalRequestInit, options);
+}
+__name(zodupload, "zodupload");
+var createForm = /* @__PURE__ */ __name(async (body) => {
+  const form = new FormData();
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+}, "createForm");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
     const response = await fetch(url, requestInitWithCache(requestInit));
@@ -1409,9 +1472,95 @@ function requestInitWithCache(requestInit) {
   }
 }
 __name(requestInitWithCache, "requestInitWithCache");
-
-// package.json
-var version = "3.0.0-beta.33";
+var addFormValue = /* @__PURE__ */ __name(async (form, key, value) => {
+  if (value === void 0)
+    return;
+  if (value == null) {
+    throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    form.append(key, String(value));
+  } else if (isUploadable(value) || isBlobLike(value) || value instanceof Buffer || value instanceof ArrayBuffer) {
+    const file = await toFile(value);
+    form.append(key, file);
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + "[]", entry)));
+  } else if (typeof value === "object") {
+    await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)));
+  } else {
+    throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+  }
+}, "addFormValue");
+async function toFile(value, name, options) {
+  value = await value;
+  options ??= isFileLike(value) ? {
+    lastModified: value.lastModified,
+    type: value.type
+  } : {};
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? "unknown_file";
+    return new File([
+      blob
+    ], name, options);
+  }
+  const bits = await getBytes(value);
+  name ||= getName(value) ?? "unknown_file";
+  if (!options.type) {
+    const type = bits[0]?.type;
+    if (typeof type === "string") {
+      options = {
+        ...options,
+        type
+      };
+    }
+  }
+  return new File(bits, name, options);
+}
+__name(toFile, "toFile");
+function getName(value) {
+  return getStringFromMaybeBuffer(value.name) || getStringFromMaybeBuffer(value.filename) || // For fs.ReadStream
+  getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop();
+}
+__name(getName, "getName");
+var getStringFromMaybeBuffer = /* @__PURE__ */ __name((x) => {
+  if (typeof x === "string")
+    return x;
+  if (typeof Buffer !== "undefined" && x instanceof Buffer)
+    return String(x);
+  return void 0;
+}, "getStringFromMaybeBuffer");
+async function getBytes(value) {
+  let parts = [];
+  if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+  value instanceof ArrayBuffer) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(await value.arrayBuffer());
+  } else if (isAsyncIterableIterator(value)) {
+    for await (const chunk of value) {
+      parts.push(chunk);
+    }
+  } else {
+    throw new Error(`Unexpected data type: ${typeof value}; constructor: ${value?.constructor?.name}; props: ${propsForError(value)}`);
+  }
+  return parts;
+}
+__name(getBytes, "getBytes");
+function propsForError(value) {
+  const props = Object.getOwnPropertyNames(value);
+  return `[${props.map((p) => `"${p}"`).join(", ")}]`;
+}
+__name(propsForError, "propsForError");
+var isAsyncIterableIterator = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function", "isAsyncIterableIterator");
+var isResponseLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function", "isResponseLike");
+var isFileLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value), "isFileLike");
+var isBlobLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function", "isBlobLike");
+var isFsReadStream = /* @__PURE__ */ __name((value) => value instanceof Readable, "isFsReadStream");
+var isUploadable = /* @__PURE__ */ __name((value) => {
+  return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
+}, "isUploadable");
+var isRecordLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => typeof key === "string" && typeof value[key] === "string"), "isRecordLike");
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
@@ -1546,6 +1695,52 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     });
   }
+  listEnvVars(projectRef, slug) {
+    return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  importEnvVars(projectRef, slug, body) {
+    if (isRecordLike(body.variables)) {
+      return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
+        method: "POST",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+        body: JSON.stringify(body)
+      });
+    } else {
+      return zodupload(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, body, {
+        method: "POST",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      });
+    }
+  }
+  retrieveEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  createEnvVar(projectRef, slug, body) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "POST",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    });
+  }
+  updateEnvVar(projectRef, slug, key, body) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "PUT",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
+      body: JSON.stringify(body)
+    });
+  }
+  deleteEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
 };
 _getHeaders = new WeakSet();
 getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
@@ -1591,7 +1786,7 @@ var _APIClientManagerAPI = class _APIClientManagerAPI {
   }
   get accessToken() {
     const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
-    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY");
+    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY") ?? getEnvVar("TRIGGER_ACCESS_TOKEN");
   }
   get client() {
     if (!this.baseURL || !this.accessToken) {