@trigger.dev/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1233 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Trigger: () => Trigger,
+  customEvent: () => customEvent,
+  getTriggerRun: () => getTriggerRun
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../internal-bridge/src/schemas/host.ts
+var import_zod7 = require("zod");
+
+// ../common-schemas/src/json.ts
+var import_zod = require("zod");
+var LiteralSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null()
+]);
+var JsonSchema = import_zod.z.lazy(() => import_zod.z.union([
+  LiteralSchema,
+  import_zod.z.array(JsonSchema),
+  import_zod.z.record(JsonSchema)
+]));
+var SerializableSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null(),
+  import_zod.z.date()
+]);
+var SerializableJsonSchema = import_zod.z.lazy(() => import_zod.z.union([
+  SerializableSchema,
+  import_zod.z.array(SerializableJsonSchema),
+  import_zod.z.record(SerializableJsonSchema)
+]));
+
+// ../common-schemas/src/error.ts
+var import_zod2 = require("zod");
+var ErrorSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  stackTrace: import_zod2.z.string().optional()
+});
+
+// ../common-schemas/src/logs.ts
+var import_zod3 = require("zod");
+var LogMessageSchema = import_zod3.z.object({
+  level: import_zod3.z.enum([
+    "DEBUG",
+    "INFO",
+    "WARN",
+    "ERROR"
+  ]),
+  message: import_zod3.z.string(),
+  properties: JsonSchema.default({})
+});
+
+// ../common-schemas/src/waits.ts
+var import_zod4 = require("zod");
+var DelaySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("DELAY"),
+  seconds: import_zod4.z.number().optional(),
+  minutes: import_zod4.z.number().optional(),
+  hours: import_zod4.z.number().optional(),
+  days: import_zod4.z.number().optional()
+});
+var ScheduledForSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SCHEDULE_FOR"),
+  scheduledFor: import_zod4.z.string().datetime()
+});
+var WaitSchema = import_zod4.z.discriminatedUnion("type", [
+  DelaySchema,
+  ScheduledForSchema
+]);
+
+// ../common-schemas/src/events.ts
+var import_zod5 = require("zod");
+var CustomEventSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  payload: JsonSchema,
+  context: JsonSchema.optional(),
+  timestamp: import_zod5.z.string().datetime().optional()
+});
+var SerializableCustomEventSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  payload: SerializableJsonSchema,
+  context: SerializableJsonSchema.optional(),
+  timestamp: import_zod5.z.string().datetime().optional()
+});
+var EventMatcherSchema = import_zod5.z.union([
+  import_zod5.z.array(import_zod5.z.string()),
+  import_zod5.z.array(import_zod5.z.number()),
+  import_zod5.z.array(import_zod5.z.boolean())
+]);
+var EventFilterSchema = import_zod5.z.lazy(() => import_zod5.z.record(import_zod5.z.union([
+  EventMatcherSchema,
+  EventFilterSchema
+])));
+
+// ../common-schemas/src/triggers.ts
+var import_zod6 = require("zod");
+var CustomEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("CUSTOM_EVENT"),
+  service: import_zod6.z.literal("trigger"),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema
+});
+var WebhookEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("WEBHOOK"),
+  service: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema,
+  source: JsonSchema
+});
+var HttpEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("HTTP_ENDPOINT"),
+  service: import_zod6.z.literal("trigger"),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema
+});
+var ScheduledEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SCHEDULE"),
+  service: import_zod6.z.literal("trigger"),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema
+});
+var TriggerMetadataSchema = import_zod6.z.discriminatedUnion("type", [
+  CustomEventTriggerSchema,
+  WebhookEventTriggerSchema,
+  HttpEventTriggerSchema,
+  ScheduledEventTriggerSchema
+]);
+
+// ../internal-bridge/src/schemas/host.ts
+var HostRPCSchema = {
+  TRIGGER_WORKFLOW: {
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      trigger: import_zod7.z.object({
+        input: JsonSchema.default({}),
+        context: JsonSchema.default({})
+      }),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string()
+      })
+    }),
+    response: import_zod7.z.boolean()
+  },
+  RESOLVE_REQUEST: {
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      output: JsonSchema.default({}),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
+      })
+    }),
+    response: import_zod7.z.boolean()
+  },
+  RESOLVE_DELAY: {
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
+      })
+    }),
+    response: import_zod7.z.boolean()
+  },
+  REJECT_REQUEST: {
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      error: JsonSchema.default({}),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
+      })
+    }),
+    response: import_zod7.z.boolean()
+  }
+};
+
+// ../internal-bridge/src/schemas/server.ts
+var import_zod8 = require("zod");
+var ServerRPCSchema = {
+  INITIALIZE_DELAY: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      wait: WaitSchema,
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  SEND_REQUEST: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      request: import_zod8.z.object({
+        service: import_zod8.z.string(),
+        endpoint: import_zod8.z.string(),
+        params: import_zod8.z.any()
+      }),
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  SEND_LOG: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      log: import_zod8.z.object({
+        message: import_zod8.z.string(),
+        level: import_zod8.z.enum([
+          "DEBUG",
+          "INFO",
+          "WARN",
+          "ERROR"
+        ]),
+        properties: import_zod8.z.string().optional()
+      }),
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  SEND_EVENT: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      event: CustomEventSchema,
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  INITIALIZE_HOST: {
+    request: import_zod8.z.object({
+      apiKey: import_zod8.z.string(),
+      workflowId: import_zod8.z.string(),
+      workflowName: import_zod8.z.string(),
+      trigger: TriggerMetadataSchema,
+      packageVersion: import_zod8.z.string(),
+      packageName: import_zod8.z.string()
+    }),
+    response: import_zod8.z.discriminatedUnion("type", [
+      import_zod8.z.object({
+        type: import_zod8.z.literal("success")
+      }),
+      import_zod8.z.object({
+        type: import_zod8.z.literal("error"),
+        message: import_zod8.z.string()
+      })
+    ]).nullable()
+  },
+  START_WORKFLOW_RUN: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  COMPLETE_WORKFLOW_RUN: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      output: import_zod8.z.string(),
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  },
+  SEND_WORKFLOW_ERROR: {
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      error: import_zod8.z.object({
+        name: import_zod8.z.string(),
+        message: import_zod8.z.string(),
+        stackTrace: import_zod8.z.string().optional()
+      }),
+      timestamp: import_zod8.z.string()
+    }),
+    response: import_zod8.z.boolean()
+  }
+};
+
+// ../internal-bridge/src/schemas/common.ts
+var import_zod9 = require("zod");
+var MESSAGE_META = import_zod9.z.object({
+  data: import_zod9.z.any(),
+  id: import_zod9.z.string(),
+  type: import_zod9.z.union([
+    import_zod9.z.literal("ACK"),
+    import_zod9.z.literal("MESSAGE")
+  ])
+});
+var TriggerEnvironmentSchema = import_zod9.z.enum([
+  "live",
+  "development"
+]);
+
+// ../internal-bridge/src/zodRPC.ts
+var import_zod10 = require("zod");
+var import_node_crypto = require("crypto");
+var RPCMessageSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  methodName: import_zod10.z.string(),
+  data: import_zod10.z.any(),
+  kind: import_zod10.z.enum([
+    "CALL",
+    "RESPONSE"
+  ])
+});
+var _connection, _sender, _receiver, _handlers, _pendingCalls, _onMessage, onMessage_fn, _onCall, onCall_fn, _onResponse, onResponse_fn, _handleCall, handleCall_fn, _handleResponse, handleResponse_fn;
+var ZodRPC = class {
+  constructor(options) {
+    __privateAdd(this, _onMessage);
+    __privateAdd(this, _onCall);
+    __privateAdd(this, _onResponse);
+    __privateAdd(this, _handleCall);
+    __privateAdd(this, _handleResponse);
+    __privateAdd(this, _connection, void 0);
+    __privateAdd(this, _sender, void 0);
+    __privateAdd(this, _receiver, void 0);
+    __privateAdd(this, _handlers, void 0);
+    __privateAdd(this, _pendingCalls, /* @__PURE__ */ new Map());
+    __privateSet(this, _connection, options.connection);
+    __privateSet(this, _sender, options.sender);
+    __privateSet(this, _receiver, options.receiver);
+    __privateSet(this, _handlers, options.handlers);
+    __privateGet(this, _connection).onMessage.attach(__privateMethod(this, _onMessage, onMessage_fn).bind(this));
+  }
+  resetConnection(connection) {
+    __privateGet(this, _connection).onMessage.detach();
+    __privateSet(this, _connection, connection);
+    __privateGet(this, _connection).onMessage.attach(__privateMethod(this, _onMessage, onMessage_fn).bind(this));
+  }
+  send(key, data) {
+    const id = generateStableId(__privateGet(this, _connection).id, key, data);
+    const message = packageMessage({
+      id,
+      methodName: key,
+      data
+    });
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _pendingCalls).set(id, (rawResponseText) => {
+        try {
+          const parsed = __privateGet(this, _sender)[key]["response"].parse(rawResponseText);
+          return resolve(parsed);
+        } catch (err) {
+          reject(err);
+        }
+      });
+      __privateGet(this, _connection).send(message).catch((err) => reject(err));
+    });
+  }
+};
+__name(ZodRPC, "ZodRPC");
+_connection = new WeakMap();
+_sender = new WeakMap();
+_receiver = new WeakMap();
+_handlers = new WeakMap();
+_pendingCalls = new WeakMap();
+_onMessage = new WeakSet();
+onMessage_fn = /* @__PURE__ */ __name(async function(rawData) {
+  try {
+    const data = RPCMessageSchema.parse(JSON.parse(rawData));
+    if (data.kind === "CALL") {
+      await __privateMethod(this, _onCall, onCall_fn).call(this, data);
+    }
+    if (data.kind === "RESPONSE") {
+      await __privateMethod(this, _onResponse, onResponse_fn).call(this, data);
+    }
+  } catch (err) {
+    console.error(err);
+  }
+}, "#onMessage");
+_onCall = new WeakSet();
+onCall_fn = /* @__PURE__ */ __name(async function(message) {
+  try {
+    await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
+  } catch (callError) {
+    if (callError instanceof import_zod10.ZodError) {
+      console.error(`[ZodRPC][foobar] Received invalid call:
+${JSON.stringify(message)}: `, callError.errors);
+    } else {
+      console.error(`[ZodRPC] Error handling call:
+${JSON.stringify(message)}: `, callError);
+    }
+  }
+}, "#onCall");
+_onResponse = new WeakSet();
+onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
+  try {
+    await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
+  } catch (callError) {
+    if (callError instanceof import_zod10.ZodError) {
+      console.error(`[ZodRPC] Received invalid response
+
+${JSON.stringify(message1)}: `, callError.flatten());
+    } else {
+      console.error(`[ZodRPC] Error handling response
+
+${JSON.stringify(message1)}: `, callError);
+    }
+  }
+}, "#onResponse");
+_handleCall = new WeakSet();
+handleCall_fn = /* @__PURE__ */ __name(async function(message2) {
+  const receiver = __privateGet(this, _receiver);
+  const methodName = message2.methodName;
+  const method = __privateGet(this, _receiver)[methodName];
+  if (!method) {
+    throw new Error(`There is no method for ${message2.methodName}`);
+  }
+  const inputs = method.request.parse(message2.data);
+  const handler = __privateGet(this, _handlers)[methodName];
+  const returnValue = await handler(inputs);
+  const preparedResponseText = packageResponse({
+    id: message2.id,
+    methodName,
+    data: returnValue
+  });
+  try {
+    await __privateGet(this, _connection).send(preparedResponseText);
+  } catch (err) {
+    console.error("Failed sending response", preparedResponseText, err);
+  }
+  return;
+}, "#handleCall");
+_handleResponse = new WeakSet();
+handleResponse_fn = /* @__PURE__ */ __name(async function(message3) {
+  const responseCallback = __privateGet(this, _pendingCalls).get(message3.id);
+  if (!responseCallback)
+    return;
+  responseCallback(message3.data);
+  __privateGet(this, _pendingCalls).delete(message3.id);
+}, "#handleResponse");
+function generateStableId(connId, reqKey, reqData) {
+  const serializedData = JSON.stringify(reqData);
+  const inputString = connId + reqKey + serializedData;
+  const hash = (0, import_node_crypto.createHash)("sha256").update(inputString).digest("hex");
+  return hash;
+}
+__name(generateStableId, "generateStableId");
+function packageMessage({ id, methodName, data }) {
+  const callerData = {
+    id,
+    kind: "CALL",
+    data,
+    methodName
+  };
+  return JSON.stringify(callerData);
+}
+__name(packageMessage, "packageMessage");
+function packageResponse({ id, methodName, data }) {
+  const preparedResponseText = {
+    id,
+    kind: "RESPONSE",
+    methodName,
+    data
+  };
+  return JSON.stringify(preparedResponseText);
+}
+__name(packageResponse, "packageResponse");
+
+// ../internal-bridge/src/logger.ts
+var logLevels = [
+  "log",
+  "error",
+  "warn",
+  "info",
+  "debug"
+];
+var _name, _level;
+var Logger = class {
+  constructor(name2, level = "info") {
+    __privateAdd(this, _name, void 0);
+    __privateAdd(this, _level, void 0);
+    __privateSet(this, _name, name2);
+    __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
+  }
+  log(...args) {
+    if (__privateGet(this, _level) < 0)
+      return;
+    console.log(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+  }
+  error(...args) {
+    if (__privateGet(this, _level) < 1)
+      return;
+    console.error(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+  }
+  warn(...args) {
+    if (__privateGet(this, _level) < 2)
+      return;
+    console.warn(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+  }
+  info(...args) {
+    if (__privateGet(this, _level) < 3)
+      return;
+    console.info(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+  }
+  debug(...args) {
+    if (__privateGet(this, _level) < 4)
+      return;
+    console.debug(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+  }
+};
+__name(Logger, "Logger");
+_name = new WeakMap();
+_level = new WeakMap();
+function formattedDateTime() {
+  const date = new Date();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const milliseconds = date.getMilliseconds();
+  const formattedHours = hours < 10 ? `0${hours}` : hours;
+  const formattedMinutes = minutes < 10 ? `0${minutes}` : minutes;
+  const formattedSeconds = seconds < 10 ? `0${seconds}` : seconds;
+  const formattedMilliseconds = milliseconds < 10 ? `00${milliseconds}` : milliseconds < 100 ? `0${milliseconds}` : milliseconds;
+  return `${formattedHours}:${formattedMinutes}:${formattedSeconds}.${formattedMilliseconds}`;
+}
+__name(formattedDateTime, "formattedDateTime");
+
+// src/client.ts
+var import_uuid2 = require("uuid");
+var import_ws = require("ws");
+
+// package.json
+var name = "@trigger.dev/sdk";
+var version = "0.1.1";
+
+// src/connection.ts
+var import_uuid = require("uuid");
+var import_evt = require("evt");
+var TimeoutError = class extends Error {
+};
+__name(TimeoutError, "TimeoutError");
+var NotConnectedError = class extends Error {
+};
+__name(NotConnectedError, "NotConnectedError");
+var _socket, _connectTimeout, _sendTimeout, _pingTimeout, _isAuthenticated, _timeouts, _isClosed, _pendingMessages, _logger, _pingIntervalHandle, _pingIntervalMs, _closeUnresponsiveConnectionTimeoutMs, _startPingInterval, startPingInterval_fn, _ping, ping_fn;
+var HostConnection = class {
+  constructor(socket, options) {
+    __privateAdd(this, _startPingInterval);
+    __privateAdd(this, _ping);
+    __privateAdd(this, _socket, void 0);
+    __privateAdd(this, _connectTimeout, void 0);
+    __privateAdd(this, _sendTimeout, void 0);
+    __privateAdd(this, _pingTimeout, void 0);
+    __privateAdd(this, _isAuthenticated, false);
+    __privateAdd(this, _timeouts, void 0);
+    __privateAdd(this, _isClosed, false);
+    __privateAdd(this, _pendingMessages, /* @__PURE__ */ new Map());
+    __privateAdd(this, _logger, void 0);
+    __privateAdd(this, _pingIntervalHandle, void 0);
+    __privateAdd(this, _pingIntervalMs, 3e4);
+    __privateAdd(this, _closeUnresponsiveConnectionTimeoutMs, 3 * 60 * 1e3);
+    __privateSet(this, _socket, socket);
+    this.id = options?.id ?? (0, import_uuid.v4)();
+    this.onMessage = new import_evt.Evt();
+    this.onAuthenticated = new import_evt.Evt();
+    this.onClose = new import_evt.Evt();
+    this.onOpen = new import_evt.Evt();
+    this.onError = new import_evt.Evt();
+    __privateSet(this, _connectTimeout, options?.connectTimeout ?? 5e3);
+    __privateSet(this, _sendTimeout, options?.sendTimeout ?? 5e3);
+    __privateSet(this, _pingTimeout, options?.pingTimeout ?? 5e3);
+    __privateSet(this, _timeouts, /* @__PURE__ */ new Set());
+    __privateSet(this, _logger, new Logger("trigger.dev connection"));
+    this.onClose.attach(() => {
+      __privateSet(this, _isClosed, true);
+      if (__privateGet(this, _pingIntervalHandle)) {
+        clearInterval(__privateGet(this, _pingIntervalHandle));
+        __privateSet(this, _pingIntervalHandle, void 0);
+      }
+      for (const timeout of __privateGet(this, _timeouts)) {
+        clearTimeout(timeout);
+      }
+      __privateGet(this, _timeouts).clear();
+    });
+    __privateGet(this, _socket).onopen = () => {
+      __privateSet(this, _isClosed, false);
+      this.onOpen.post();
+      __privateMethod(this, _startPingInterval, startPingInterval_fn).call(this);
+    };
+    __privateGet(this, _socket).onclose = (ev) => {
+      this.onClose.post([
+        ev.code,
+        ev.reason
+      ]);
+    };
+    __privateGet(this, _socket).onerror = (ev) => {
+      const message = "message" in ev ? ev.message : "Unknown error";
+      this.onError.post(new Error(message));
+    };
+    __privateGet(this, _socket).onmessage = (event) => {
+      if (__privateGet(this, _isClosed))
+        return;
+      const data = JSON.parse(event.data.toString());
+      const metadata = MESSAGE_META.parse(data);
+      if (metadata.type === "ACK") {
+        const pendingMessage = __privateGet(this, _pendingMessages).get(metadata.id);
+        if (pendingMessage) {
+          pendingMessage.onAckReceived();
+          __privateGet(this, _pendingMessages).delete(metadata.id);
+        }
+      }
+      if (metadata.type === "MESSAGE") {
+        socket.send(JSON.stringify({
+          type: "ACK",
+          id: metadata.id
+        }));
+        if (metadata.data === "AUTHENTICATED") {
+          __privateSet(this, _isAuthenticated, true);
+          this.onAuthenticated.post();
+          return;
+        }
+        this.onMessage.post(metadata.data);
+      }
+    };
+    if ("pong" in socket) {
+      socket.on("pong", (buf) => {
+        const id = buf.toString();
+        const pendingMessage = __privateGet(this, _pendingMessages).get(id);
+        if (pendingMessage?.data === "ping") {
+          pendingMessage.onAckReceived();
+        }
+      });
+    }
+  }
+  async connect() {
+    __privateGet(this, _logger).debug("[connect] Attempting to connect");
+    return new Promise((resolve, reject) => {
+      if (__privateGet(this, _socket).readyState === __privateGet(this, _socket).OPEN && __privateGet(this, _isAuthenticated)) {
+        __privateGet(this, _logger).debug("[connect] Already connected, resolving");
+        return resolve();
+      }
+      const failTimeout = setTimeout(() => {
+        __privateGet(this, _logger).debug("[connect] Connection timed out, rejecting");
+        reject(new TimeoutError());
+      }, __privateGet(this, _connectTimeout));
+      __privateGet(this, _timeouts).add(failTimeout);
+      this.onAuthenticated.attach(() => {
+        clearTimeout(failTimeout);
+        __privateGet(this, _timeouts).delete(failTimeout);
+        __privateGet(this, _logger).debug("[connect] Connected, resolving");
+        resolve();
+      });
+    });
+  }
+  async send(data) {
+    if (__privateGet(this, _isClosed))
+      throw new NotConnectedError();
+    return new Promise((resolve, reject) => {
+      const id = (0, import_uuid.v4)();
+      const failTimeout = setTimeout(() => {
+        reject(new TimeoutError());
+      }, __privateGet(this, _sendTimeout));
+      __privateGet(this, _timeouts).add(failTimeout);
+      __privateGet(this, _pendingMessages).set(id, {
+        data,
+        onAckReceived: () => {
+          clearTimeout(failTimeout);
+          __privateGet(this, _timeouts).delete(failTimeout);
+          resolve();
+        }
+      });
+      __privateGet(this, _socket).send(JSON.stringify({
+        id,
+        data,
+        type: "MESSAGE"
+      }));
+    });
+  }
+  close(code, reason) {
+    __privateSet(this, _isClosed, true);
+    this.onMessage.detach();
+    return __privateGet(this, _socket).close(code, reason);
+  }
+};
+__name(HostConnection, "HostConnection");
+_socket = new WeakMap();
+_connectTimeout = new WeakMap();
+_sendTimeout = new WeakMap();
+_pingTimeout = new WeakMap();
+_isAuthenticated = new WeakMap();
+_timeouts = new WeakMap();
+_isClosed = new WeakMap();
+_pendingMessages = new WeakMap();
+_logger = new WeakMap();
+_pingIntervalHandle = new WeakMap();
+_pingIntervalMs = new WeakMap();
+_closeUnresponsiveConnectionTimeoutMs = new WeakMap();
+_startPingInterval = new WeakSet();
+startPingInterval_fn = /* @__PURE__ */ __name(function() {
+  let lastSuccessfulPing = new Date();
+  __privateSet(this, _pingIntervalHandle, setInterval(async () => {
+    if (!__privateGet(this, _socket).OPEN) {
+      if (__privateGet(this, _pingIntervalHandle)) {
+        clearInterval(__privateGet(this, _pingIntervalHandle));
+        __privateSet(this, _pingIntervalHandle, void 0);
+      }
+      return;
+    }
+    try {
+      await __privateMethod(this, _ping, ping_fn).call(this);
+      lastSuccessfulPing = new Date();
+    } catch (err) {
+      __privateGet(this, _logger).warn("Pong not received in time");
+      if (!(err instanceof TimeoutError)) {
+        __privateGet(this, _logger).error(err);
+      }
+      if (lastSuccessfulPing.getTime() < new Date().getTime() - __privateGet(this, _closeUnresponsiveConnectionTimeoutMs)) {
+        __privateGet(this, _logger).error("No pong received in last three minutes, closing connection to Interval and retrying...");
+        if (__privateGet(this, _pingIntervalHandle)) {
+          clearInterval(__privateGet(this, _pingIntervalHandle));
+          __privateSet(this, _pingIntervalHandle, void 0);
+        }
+        __privateGet(this, _socket).close();
+      }
+    }
+  }, __privateGet(this, _pingIntervalMs)));
+}, "#startPingInterval");
+_ping = new WeakSet();
+ping_fn = /* @__PURE__ */ __name(async function() {
+  if (!__privateGet(this, _socket).OPEN) {
+    throw new NotConnectedError();
+  }
+  if (!("ping" in __privateGet(this, _socket))) {
+    throw new Error("ping not supported in this underlying websocket connection");
+  }
+  const socket = __privateGet(this, _socket);
+  return new Promise((resolve, reject) => {
+    const id = (0, import_uuid.v4)();
+    const failTimeout = setTimeout(() => {
+      reject(new TimeoutError("Pong not received in time"));
+    }, __privateGet(this, _pingTimeout));
+    __privateGet(this, _timeouts).add(failTimeout);
+    __privateGet(this, _pendingMessages).set(id, {
+      data: "ping",
+      onAckReceived: () => {
+        clearTimeout(failTimeout);
+        __privateGet(this, _timeouts).delete(failTimeout);
+        __privateGet(this, _logger).debug(`Resolving ping`);
+        resolve();
+      }
+    });
+    __privateGet(this, _logger).debug(`Sending ping ${id} to ${socket.url}`);
+    socket.ping(id, void 0, (err) => {
+      if (err) {
+        reject(err);
+      }
+    });
+  });
+}, "#ping");
+
+// src/localStorage.ts
+var import_node_async_hooks = require("async_hooks");
+var triggerRunLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+
+// src/logger.ts
+var ContextLogger = class {
+  constructor(callback) {
+    this.callback = callback;
+  }
+  debug(message, properties) {
+    return this.callback("DEBUG", message, properties);
+  }
+  info(message, properties) {
+    return this.callback("INFO", message, properties);
+  }
+  warn(message, properties) {
+    return this.callback("WARN", message, properties);
+  }
+  error(message, properties) {
+    return this.callback("ERROR", message, properties);
+  }
+};
+__name(ContextLogger, "ContextLogger");
+
+// src/client.ts
+var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger2, _closedByUser, _responseCompleteCallbacks, _waitForCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
+var TriggerClient = class {
+  constructor(trigger, options) {
+    __privateAdd(this, _initializeConnection);
+    __privateAdd(this, _initializeRPC);
+    __privateAdd(this, _initializeHost);
+    __privateAdd(this, _send);
+    __privateAdd(this, _trigger, void 0);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _connection2, void 0);
+    __privateAdd(this, _serverRPC, void 0);
+    __privateAdd(this, _apiKey, void 0);
+    __privateAdd(this, _endpoint, void 0);
+    __privateAdd(this, _isConnected, false);
+    __privateAdd(this, _retryIntervalMs, 3e3);
+    __privateAdd(this, _logger2, void 0);
+    __privateAdd(this, _closedByUser, false);
+    __privateAdd(this, _responseCompleteCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
+    __privateSet(this, _trigger, trigger);
+    __privateSet(this, _options, options);
+    const apiKey = __privateGet(this, _options).apiKey ?? process.env.TRIGGER_API_KEY;
+    if (!apiKey) {
+      throw new Error("Cannot connect to Trigger because of invalid API Key: Please include an API Key in the `apiKey` option or in the `TRIGGER_API_KEY` environment variable.");
+    }
+    __privateSet(this, _apiKey, apiKey);
+    __privateSet(this, _endpoint, __privateGet(this, _options).endpoint ?? "wss://wss.trigger.dev/ws");
+    __privateSet(this, _logger2, new Logger("trigger.dev", __privateGet(this, _options).logLevel));
+  }
+  async listen(instanceId) {
+    await __privateMethod(this, _initializeConnection, initializeConnection_fn).call(this, instanceId);
+    __privateMethod(this, _initializeRPC, initializeRPC_fn).call(this);
+    __privateMethod(this, _initializeHost, initializeHost_fn).call(this);
+  }
+  close() {
+    __privateSet(this, _closedByUser, true);
+    if (__privateGet(this, _serverRPC)) {
+      __privateSet(this, _serverRPC, void 0);
+    }
+    __privateGet(this, _connection2)?.close();
+    __privateSet(this, _isConnected, false);
+  }
+};
+__name(TriggerClient, "TriggerClient");
+_trigger = new WeakMap();
+_options = new WeakMap();
+_connection2 = new WeakMap();
+_serverRPC = new WeakMap();
+_apiKey = new WeakMap();
+_endpoint = new WeakMap();
+_isConnected = new WeakMap();
+_retryIntervalMs = new WeakMap();
+_logger2 = new WeakMap();
+_closedByUser = new WeakMap();
+_responseCompleteCallbacks = new WeakMap();
+_waitForCallbacks = new WeakMap();
+_initializeConnection = new WeakSet();
+initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
+  const id = instanceId ?? (0, import_uuid2.v4)();
+  __privateGet(this, _logger2).debug("Initializing connection", {
+    id,
+    endpoint: __privateGet(this, _endpoint)
+  });
+  const headers = {
+    Authorization: `Bearer ${__privateGet(this, _apiKey)}`
+  };
+  const connection = new HostConnection(new import_ws.WebSocket(__privateGet(this, _endpoint), {
+    headers,
+    followRedirects: true
+  }), {
+    id
+  });
+  connection.onClose.attach(async ([code, reason]) => {
+    if (__privateGet(this, _closedByUser)) {
+      __privateGet(this, _logger2).debug("Connection closed by user, so we won't reconnect");
+      __privateSet(this, _closedByUser, false);
+      return;
+    }
+    __privateGet(this, _logger2).error(`\u{1F6A9} Could not connect to trigger.dev (code ${code})`);
+    if (reason) {
+      __privateGet(this, _logger2).error("Reason:", reason);
+    }
+    if (!__privateGet(this, _isConnected))
+      return;
+    __privateGet(this, _logger2).log("\u{1F50C} Reconnecting to trigger.dev...");
+    __privateSet(this, _isConnected, false);
+    while (!__privateGet(this, _isConnected)) {
+      __privateMethod(this, _initializeConnection, initializeConnection_fn).call(this, id).then(() => {
+        __privateGet(this, _logger2).log("\u26A1 Reconnection successful");
+      }).catch(() => {
+      });
+      __privateGet(this, _logger2).debug(`Reconnection failed, retrying in ${Math.round(__privateGet(this, _retryIntervalMs) / 1e3)} seconds`, id);
+      await new Promise((resolve) => setTimeout(resolve, __privateGet(this, _retryIntervalMs)));
+    }
+  });
+  await connection.connect();
+  __privateGet(this, _logger2).debug("Connection initialized", id);
+  __privateSet(this, _connection2, connection);
+  __privateSet(this, _isConnected, true);
+  if (__privateGet(this, _serverRPC)) {
+    __privateGet(this, _serverRPC).resetConnection(connection);
+    await __privateMethod(this, _initializeHost, initializeHost_fn).call(this);
+  }
+}, "#initializeConnection");
+_initializeRPC = new WeakSet();
+initializeRPC_fn = /* @__PURE__ */ __name(async function() {
+  if (!__privateGet(this, _connection2)) {
+    throw new Error("Cannot initialize RPC without a connection");
+  }
+  const serverRPC = new ZodRPC({
+    connection: __privateGet(this, _connection2),
+    sender: ServerRPCSchema,
+    receiver: HostRPCSchema,
+    handlers: {
+      RESOLVE_DELAY: async (data) => {
+        __privateGet(this, _logger2).debug("Handling RESOLVE_DELAY", data);
+        const waitCallbacks = __privateGet(this, _waitForCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!waitCallbacks) {
+          __privateGet(this, _logger2).debug(`Could not find wait callbacks for wait ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = waitCallbacks;
+        resolve();
+        return true;
+      },
+      RESOLVE_REQUEST: async (data) => {
+        __privateGet(this, _logger2).debug("Handling RESOLVE_REQUEST", data);
+        const requestCallbacks = __privateGet(this, _responseCompleteCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!requestCallbacks) {
+          __privateGet(this, _logger2).debug(`Could not find request callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = requestCallbacks;
+        resolve(data.output);
+        return true;
+      },
+      REJECT_REQUEST: async (data) => {
+        __privateGet(this, _logger2).debug("Handling REJECT_REQUEST", data);
+        const requestCallbacks = __privateGet(this, _responseCompleteCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!requestCallbacks) {
+          __privateGet(this, _logger2).debug(`Could not find request callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { reject } = requestCallbacks;
+        reject(data.error);
+        return true;
+      },
+      TRIGGER_WORKFLOW: async (data) => {
+        __privateGet(this, _logger2).debug("Handling TRIGGER_WORKFLOW", data);
+        const ctx = {
+          id: data.id,
+          environment: data.meta.environment,
+          apiKey: data.meta.apiKey,
+          organizationId: data.meta.organizationId,
+          logger: new ContextLogger(async (level, message, properties) => {
+            await serverRPC.send("SEND_LOG", {
+              runId: data.id,
+              key: message,
+              log: {
+                level,
+                message,
+                properties: JSON.stringify(properties ?? {})
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+          }),
+          fireEvent: async (key, event) => {
+            await serverRPC.send("SEND_EVENT", {
+              runId: data.id,
+              key,
+              event: JSON.parse(JSON.stringify(event)),
+              timestamp: String(highPrecisionTimestamp())
+            });
+          },
+          waitFor: async (key, options) => {
+            const result = new Promise((resolve, reject) => {
+              __privateGet(this, _waitForCallbacks).set(messageKey(data.id, key), {
+                resolve,
+                reject
+              });
+            });
+            await serverRPC.send("INITIALIZE_DELAY", {
+              runId: data.id,
+              key,
+              wait: {
+                type: "DELAY",
+                seconds: options.seconds,
+                minutes: options.minutes,
+                hours: options.hours,
+                days: options.days
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            await result;
+            return;
+          },
+          waitUntil: async (key, date) => {
+            const result = new Promise((resolve, reject) => {
+              __privateGet(this, _waitForCallbacks).set(messageKey(data.id, key), {
+                resolve,
+                reject
+              });
+            });
+            await serverRPC.send("INITIALIZE_DELAY", {
+              runId: data.id,
+              key,
+              wait: {
+                type: "SCHEDULE_FOR",
+                scheduledFor: date.toISOString()
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            await result;
+            return;
+          }
+        };
+        const eventData = __privateGet(this, _options).on.schema.parse(data.trigger.input);
+        __privateGet(this, _logger2).debug("Parsed event data", eventData);
+        triggerRunLocalStorage.run({
+          performRequest: async (key, options) => {
+            const result = new Promise((resolve, reject) => {
+              __privateGet(this, _responseCompleteCallbacks).set(messageKey(data.id, key), {
+                resolve,
+                reject
+              });
+            });
+            await serverRPC.send("SEND_REQUEST", {
+              runId: data.id,
+              key,
+              request: {
+                service: options.service,
+                endpoint: options.endpoint,
+                params: options.params
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            const output = await result;
+            return options.response.schema.parse(output);
+          }
+        }, () => {
+          __privateGet(this, _logger2).debug("Running trigger...");
+          serverRPC.send("START_WORKFLOW_RUN", {
+            runId: data.id,
+            timestamp: String(highPrecisionTimestamp())
+          }).then(() => {
+            return __privateGet(this, _trigger).options.run(eventData, ctx).then((output) => {
+              return serverRPC.send("COMPLETE_WORKFLOW_RUN", {
+                runId: data.id,
+                output: JSON.stringify(output),
+                timestamp: String(highPrecisionTimestamp())
+              });
+            }).catch((anyError) => {
+              const parseAnyError = /* @__PURE__ */ __name((error2) => {
+                if (error2 instanceof Error) {
+                  return {
+                    name: error2.name,
+                    message: error2.message,
+                    stackTrace: error2.stack
+                  };
+                }
+                console.error(anyError);
+                return {
+                  name: "UnknownError",
+                  message: "An unknown error occurred"
+                };
+              }, "parseAnyError");
+              const error = parseAnyError(anyError);
+              return serverRPC.send("SEND_WORKFLOW_ERROR", {
+                runId: data.id,
+                error,
+                timestamp: String(highPrecisionTimestamp())
+              });
+            });
+          }).catch((anyError) => {
+            return serverRPC.send("SEND_WORKFLOW_ERROR", {
+              runId: data.id,
+              error: anyError,
+              timestamp: String(highPrecisionTimestamp())
+            });
+          });
+        });
+        return true;
+      }
+    }
+  });
+  __privateGet(this, _logger2).debug("Successfully initialized RPC with server");
+  __privateSet(this, _serverRPC, serverRPC);
+}, "#initializeRPC");
+_initializeHost = new WeakSet();
+initializeHost_fn = /* @__PURE__ */ __name(async function() {
+  if (!__privateGet(this, _connection2)) {
+    throw new Error("Cannot initialize host without a connection");
+  }
+  if (!__privateGet(this, _serverRPC)) {
+    throw new Error("Cannot initialize host without an RPC connection");
+  }
+  const response = await __privateMethod(this, _send, send_fn).call(this, "INITIALIZE_HOST", {
+    apiKey: __privateGet(this, _apiKey),
+    workflowId: __privateGet(this, _trigger).id,
+    workflowName: __privateGet(this, _trigger).name,
+    trigger: __privateGet(this, _trigger).on.metadata,
+    packageVersion: version,
+    packageName: name
+  });
+  if (response?.type === "error") {
+    throw new Error(response.message);
+  }
+  __privateGet(this, _logger2).debug("Successfully initialized workflow with server");
+}, "#initializeHost");
+_send = new WeakSet();
+send_fn = /* @__PURE__ */ __name(async function(methodName, request) {
+  if (!__privateGet(this, _serverRPC))
+    throw new Error("serverRPC not initialized");
+  while (true) {
+    try {
+      __privateGet(this, _logger2).debug(`Sending RPC request to server: ${methodName}`, request);
+      return await __privateGet(this, _serverRPC).send(methodName, request);
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        __privateGet(this, _logger2).log(`RPC call timed out, retrying in ${Math.round(__privateGet(this, _retryIntervalMs) / 1e3)}s...`);
+        __privateGet(this, _logger2).error(err);
+        await sleep(__privateGet(this, _retryIntervalMs));
+      } else {
+        throw err;
+      }
+    }
+  }
+}, "#send");
+var sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+var messageKey = /* @__PURE__ */ __name((runId, key) => `${runId}:${key}`, "messageKey");
+function highPrecisionTimestamp() {
+  const [seconds, nanoseconds] = process.hrtime();
+  return seconds * 1e9 + nanoseconds;
+}
+__name(highPrecisionTimestamp, "highPrecisionTimestamp");
+
+// src/trigger/index.ts
+var _client;
+var Trigger = class {
+  constructor(options) {
+    __privateAdd(this, _client, void 0);
+    this.options = options;
+  }
+  async listen() {
+    if (!__privateGet(this, _client)) {
+      __privateSet(this, _client, new TriggerClient(this, this.options));
+    }
+    return __privateGet(this, _client).listen();
+  }
+  get id() {
+    return this.options.id;
+  }
+  get name() {
+    return this.options.name;
+  }
+  get endpoint() {
+    return this.options.endpoint;
+  }
+  get on() {
+    return this.options.on;
+  }
+};
+__name(Trigger, "Trigger");
+_client = new WeakMap();
+
+// src/events.ts
+function customEvent(options) {
+  return {
+    metadata: {
+      type: "CUSTOM_EVENT",
+      service: "trigger",
+      name: options.name,
+      filter: {
+        event: [
+          options.name
+        ]
+      }
+    },
+    schema: options.schema
+  };
+}
+__name(customEvent, "customEvent");
+
+// src/index.ts
+function getTriggerRun() {
+  return triggerRunLocalStorage.getStore();
+}
+__name(getTriggerRun, "getTriggerRun");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Trigger,
+  customEvent,
+  getTriggerRun
+});
+//# sourceMappingURL=index.js.map