trigger.dev 0.0.0-prerelease-20240219135254

package/dist/index.js

@@ -0,0 +1,3106 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
+var require_XDGAppPaths = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function isBoolean(t) {
+      return typeOf(t) === "boolean";
+    }
+    function isObject(t) {
+      return typeOf(t) === "object";
+    }
+    function isString(t) {
+      return typeOf(t) === "string";
+    }
+    function typeOf(t) {
+      return typeof t;
+    }
+    function Adapt(adapter_) {
+      var meta = adapter_.meta, path6 = adapter_.path, xdg = adapter_.xdg;
+      var XDGAppPaths_ = /* @__PURE__ */ function() {
+        function XDGAppPaths_2(options_) {
+          if (options_ === void 0) {
+            options_ = {};
+          }
+          var _a, _b, _c;
+          function XDGAppPaths(options2) {
+            if (options2 === void 0) {
+              options2 = {};
+            }
+            return new XDGAppPaths_2(options2);
+          }
+          var options = isObject(options_) ? options_ : { name: options_ };
+          var suffix = (_a = options.suffix) !== null && _a !== void 0 ? _a : "";
+          var isolated_ = (_b = options.isolated) !== null && _b !== void 0 ? _b : true;
+          var namePriorityList = [
+            options.name,
+            meta.pkgMainFilename(),
+            meta.mainFilename()
+          ];
+          var nameFallback = "$eval";
+          var name = path6.parse(((_c = namePriorityList.find(function(e) {
+            return isString(e);
+          })) !== null && _c !== void 0 ? _c : nameFallback) + suffix).name;
+          XDGAppPaths.$name = function $name() {
+            return name;
+          };
+          XDGAppPaths.$isolated = function $isolated() {
+            return isolated_;
+          };
+          function isIsolated(dirOptions) {
+            var _a2;
+            dirOptions = dirOptions !== null && dirOptions !== void 0 ? dirOptions : { isolated: isolated_ };
+            var isolated = isBoolean(dirOptions) ? dirOptions : (_a2 = dirOptions.isolated) !== null && _a2 !== void 0 ? _a2 : isolated_;
+            return isolated;
+          }
+          function finalPathSegment(dirOptions) {
+            return isIsolated(dirOptions) ? name : "";
+          }
+          XDGAppPaths.cache = function cache(dirOptions) {
+            return path6.join(xdg.cache(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.config = function config(dirOptions) {
+            return path6.join(xdg.config(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.data = function data(dirOptions) {
+            return path6.join(xdg.data(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.runtime = function runtime(dirOptions) {
+            return xdg.runtime() ? path6.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+          };
+          XDGAppPaths.state = function state(dirOptions) {
+            return path6.join(xdg.state(), finalPathSegment(dirOptions));
+          };
+          XDGAppPaths.configDirs = function configDirs(dirOptions) {
+            return xdg.configDirs().map(function(s) {
+              return path6.join(s, finalPathSegment(dirOptions));
+            });
+          };
+          XDGAppPaths.dataDirs = function dataDirs(dirOptions) {
+            return xdg.dataDirs().map(function(s) {
+              return path6.join(s, finalPathSegment(dirOptions));
+            });
+          };
+          return XDGAppPaths;
+        }
+        return XDGAppPaths_2;
+      }();
+      return { XDGAppPaths: new XDGAppPaths_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js
+var require_XDG = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js"(exports) {
+    "use strict";
+    var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+      return to;
+    };
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function Adapt(adapter_) {
+      var env = adapter_.env, osPaths = adapter_.osPaths, path6 = adapter_.path;
+      var isMacOS = /^darwin$/i.test(adapter_.process.platform);
+      var isWinOS = /^win/i.test(adapter_.process.platform);
+      function baseDir() {
+        return osPaths.home() || osPaths.temp();
+      }
+      function valOrPath(val, pathSegments) {
+        return val || path6.join.apply(path6, pathSegments);
+      }
+      var linux = function() {
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), ".cache"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), ".config"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), ".local", "share"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), ".local", "state"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var macos = function() {
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), "Library", "Caches"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), "Library", "Preferences"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), "Library", "Application Support"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), "Library", "State"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var windows = function() {
+        function appData() {
+          return valOrPath(env.get("APPDATA"), [baseDir(), "AppData", "Roaming"]);
+        }
+        function localAppData() {
+          return valOrPath(env.get("LOCALAPPDATA"), [baseDir(), "AppData", "Local"]);
+        }
+        var cache = function() {
+          return valOrPath(env.get("XDG_CACHE_HOME"), [localAppData(), "xdg.cache"]);
+        };
+        var config = function() {
+          return valOrPath(env.get("XDG_CONFIG_HOME"), [appData(), "xdg.config"]);
+        };
+        var data = function() {
+          return valOrPath(env.get("XDG_DATA_HOME"), [appData(), "xdg.data"]);
+        };
+        var runtime = function() {
+          return env.get("XDG_RUNTIME_DIR") || void 0;
+        };
+        var state = function() {
+          return valOrPath(env.get("XDG_STATE_HOME"), [localAppData(), "xdg.state"]);
+        };
+        return { cache, config, data, runtime, state };
+      };
+      var XDG_ = /* @__PURE__ */ function() {
+        function XDG_2() {
+          function XDG() {
+            return new XDG_2();
+          }
+          var extension = isMacOS ? macos() : isWinOS ? windows() : linux();
+          XDG.cache = extension.cache;
+          XDG.config = extension.config;
+          XDG.data = extension.data;
+          XDG.runtime = extension.runtime;
+          XDG.state = extension.state;
+          XDG.configDirs = function configDirs() {
+            var pathList = env.get("XDG_CONFIG_DIRS");
+            return __spreadArray([extension.config()], pathList ? pathList.split(path6.delimiter) : []);
+          };
+          XDG.dataDirs = function dataDirs() {
+            var pathList = env.get("XDG_DATA_DIRS");
+            return __spreadArray([extension.data()], pathList ? pathList.split(path6.delimiter) : []);
+          };
+          return XDG;
+        }
+        return XDG_2;
+      }();
+      return { XDG: new XDG_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js
+var require_OSPaths = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js"(exports) {
+    "use strict";
+    var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+      return to;
+    };
+    exports.__esModule = true;
+    exports.Adapt = void 0;
+    function isEmpty(s) {
+      return !s;
+    }
+    function Adapt(adapter_) {
+      var env = adapter_.env, os2 = adapter_.os, path6 = adapter_.path;
+      var isWinOS = /^win/i.test(adapter_.process.platform);
+      function normalizePath(path_) {
+        return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
+      }
+      function home() {
+        var posix = function() {
+          return normalizePath((typeof os2.homedir === "function" ? os2.homedir() : void 0) || env.get("HOME"));
+        };
+        var windows = function() {
+          var priorityList = [
+            typeof os2.homedir === "function" ? os2.homedir() : void 0,
+            env.get("USERPROFILE"),
+            env.get("HOME"),
+            env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path6.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
+          ];
+          return normalizePath(priorityList.find(function(v) {
+            return !isEmpty(v);
+          }));
+        };
+        return isWinOS ? windows() : posix();
+      }
+      function temp() {
+        function joinPathToBase(base, segments) {
+          return base ? path6.join.apply(path6, __spreadArray([base], segments)) : void 0;
+        }
+        function posix() {
+          var fallback = "/tmp";
+          var priorityList = [
+            typeof os2.tmpdir === "function" ? os2.tmpdir() : void 0,
+            env.get("TMPDIR"),
+            env.get("TEMP"),
+            env.get("TMP")
+          ];
+          return normalizePath(priorityList.find(function(v) {
+            return !isEmpty(v);
+          })) || fallback;
+        }
+        function windows() {
+          var fallback = "C:\\Temp";
+          var priorityListLazy = [
+            typeof os2.tmpdir === "function" ? os2.tmpdir : function() {
+              return void 0;
+            },
+            function() {
+              return env.get("TEMP");
+            },
+            function() {
+              return env.get("TMP");
+            },
+            function() {
+              return joinPathToBase(env.get("LOCALAPPDATA"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(home(), ["AppData", "Local", "Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("ALLUSERSPROFILE"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("SystemRoot"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("windir"), ["Temp"]);
+            },
+            function() {
+              return joinPathToBase(env.get("SystemDrive"), ["\\", "Temp"]);
+            }
+          ];
+          var v = priorityListLazy.find(function(v2) {
+            return v2 && !isEmpty(v2());
+          });
+          return v && normalizePath(v()) || fallback;
+        }
+        return isWinOS ? windows() : posix();
+      }
+      var OSPaths_ = /* @__PURE__ */ function() {
+        function OSPaths_2() {
+          function OSPaths() {
+            return new OSPaths_2();
+          }
+          OSPaths.home = home;
+          OSPaths.temp = temp;
+          return OSPaths;
+        }
+        return OSPaths_2;
+      }();
+      return { OSPaths: new OSPaths_() };
+    }
+    exports.Adapt = Adapt;
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var os2 = __importStar(__require("os"));
+    var path6 = __importStar(__require("path"));
+    exports.adapter = {
+      atImportPermissions: { env: true },
+      env: {
+        get: function(s) {
+          return process.env[s];
+        }
+      },
+      os: os2,
+      path: path6,
+      process
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs = __commonJS({
+  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var OSPaths_js_1 = require_OSPaths();
+    var node_js_1 = require_node();
+    module.exports = OSPaths_js_1.Adapt(node_js_1.adapter).OSPaths;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js
+var require_node2 = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var path6 = __importStar(__require("path"));
+    var os_paths_1 = __importDefault(require_mod_cjs());
+    exports.adapter = {
+      atImportPermissions: { env: true },
+      env: {
+        get: function(s) {
+          return process.env[s];
+        }
+      },
+      osPaths: os_paths_1["default"],
+      path: path6,
+      process
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js
+var require_mod_cjs2 = __commonJS({
+  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var XDG_js_1 = require_XDG();
+    var node_js_1 = require_node2();
+    module.exports = XDG_js_1.Adapt(node_js_1.adapter).XDG;
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js
+var require_node3 = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    exports.__esModule = true;
+    exports.adapter = void 0;
+    var path6 = __importStar(__require("path"));
+    var xdg_portable_1 = __importDefault(require_mod_cjs2());
+    exports.adapter = {
+      atImportPermissions: { env: true, read: true },
+      meta: {
+        mainFilename: function() {
+          var requireMain = typeof __require !== "undefined" && __require !== null && __require.main ? __require.main : { filename: void 0 };
+          var requireMainFilename = requireMain.filename;
+          var filename = (requireMainFilename !== process.execArgv[0] ? requireMainFilename : void 0) || (typeof process._eval === "undefined" ? process.argv[1] : void 0);
+          return filename;
+        },
+        pkgMainFilename: function() {
+          return process.pkg ? process.execPath : void 0;
+        }
+      },
+      path: path6,
+      process,
+      xdg: xdg_portable_1["default"]
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs3 = __commonJS({
+  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js"(exports, module) {
+    "use strict";
+    var XDGAppPaths_js_1 = require_XDGAppPaths();
+    var node_js_1 = require_node3();
+    module.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_retry();
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { z as z5 } from "zod";
+
+// src/commands/dev.tsx
+import {
+  ZodMessageHandler as ZodMessageHandler2,
+  ZodMessageSender as ZodMessageSender2,
+  clientWebsocketMessages,
+  serverWebsocketMessages
+} from "@trigger.dev/core/v3";
+import chalk5 from "chalk";
+import { watch } from "chokidar";
+import { context } from "esbuild";
+import { findUp } from "find-up";
+import { resolve as importResolve } from "import-meta-resolve";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { createHash } from "node:crypto";
+import fs, { readFileSync as readFileSync2 } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import pThrottle from "p-throttle";
+import { WebSocket } from "partysocket";
+import React, { Suspense, useEffect } from "react";
+import { WebSocket as wsWebSocket } from "ws";
+import { z as z3 } from "zod";
+
+// package.json
+var version = "0.0.0-prerelease-20240219135254";
+var package_default = {
+  name: "trigger.dev",
+  version,
+  description: "A Command-Line Interface for Trigger.dev (v3) projects",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/triggerdotdev/trigger.dev.git",
+    directory: "packages/cli-v3"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "typescript",
+    "trigger.dev",
+    "workflows",
+    "orchestration",
+    "events",
+    "webhooks",
+    "integrations",
+    "apis",
+    "jobs",
+    "background jobs",
+    "nextjs"
+  ],
+  files: [
+    "dist"
+  ],
+  type: "module",
+  exports: "./dist/index.js",
+  bin: {
+    "trigger.dev": "./dist/index.js"
+  },
+  devDependencies: {
+    "@trigger.dev/core": "workspace:*",
+    "@trigger.dev/tsconfig": "workspace:*",
+    "@types/gradient-string": "^1.1.2",
+    "@types/mock-fs": "^4.13.1",
+    "@types/node": "18",
+    "@types/object-hash": "^3.0.6",
+    "@types/react": "^18.2.48",
+    "@types/ws": "^8.5.3",
+    "npm-run-all": "^4.1.5",
+    open: "^10.0.3",
+    "p-retry": "^6.1.0",
+    rimraf: "^3.0.2",
+    tsup: "^8.0.1",
+    "type-fest": "^3.6.0",
+    typescript: "^5.3.3",
+    vitest: "^0.34.4",
+    "xdg-app-paths": "^8.3.0"
+  },
+  scripts: {
+    typecheck: "tsc",
+    build: "npm run clean && run-p build:**",
+    "build:main": "tsup",
+    "build:facade": "tsup --config tsup.facade.config.ts",
+    dev: "npm run clean && run-p dev:**",
+    "dev:main": "tsup --watch",
+    "dev:facade": "tsup --config tsup.facade.config.ts --watch",
+    clean: "rimraf dist",
+    start: "node dist/index.js",
+    test: "vitest"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.7.0",
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/api-logs": "^0.48.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.40.3",
+    "@opentelemetry/exporter-collector": "^0.25.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.48.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.48.0",
+    "@opentelemetry/instrumentation": "^0.48.0",
+    "@opentelemetry/instrumentation-fetch": "^0.48.0",
+    "@opentelemetry/instrumentation-http": "^0.48.0",
+    "@opentelemetry/resources": "^1.21.0",
+    "@opentelemetry/sdk-logs": "^0.48.0",
+    "@opentelemetry/sdk-node": "^0.48.0",
+    "@opentelemetry/sdk-trace-base": "^1.21.0",
+    "@opentelemetry/sdk-trace-node": "^1.21.0",
+    "@opentelemetry/semantic-conventions": "^1.21.0",
+    "@trigger.dev/core": "workspace:*",
+    "@types/degit": "^2.8.3",
+    chalk: "^5.2.0",
+    chokidar: "^3.5.3",
+    "cli-table3": "^0.6.3",
+    commander: "^9.4.1",
+    degit: "^2.8.4",
+    dotenv: "^16.3.1",
+    esbuild: "^0.19.11",
+    evt: "^2.4.13",
+    execa: "^7.0.0",
+    "find-up": "^7.0.0",
+    "gradient-string": "^2.0.2",
+    "import-meta-resolve": "^4.0.0",
+    ink: "^4.4.1",
+    liquidjs: "^10.9.2",
+    "mock-fs": "^5.2.0",
+    nanoid: "^4.0.2",
+    "node-fetch": "^3.3.0",
+    "npm-check-updates": "^16.12.2",
+    "object-hash": "^3.0.0",
+    "p-throttle": "^6.1.0",
+    partysocket: "^0.0.17",
+    "posthog-node": "^3.1.1",
+    "proxy-agent": "^6.3.0",
+    react: "^18.2.0",
+    "react-error-boundary": "^4.0.12",
+    "simple-git": "^3.19.0",
+    "source-map": "^0.7.4",
+    "supports-color": "^9.4.0",
+    "terminal-link": "^3.0.0",
+    "update-check": "^1.5.4",
+    url: "^0.11.1",
+    ws: "^8.12.0",
+    zod: "3.22.3"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/apiClient.ts
+import {
+  CreateAuthorizationCodeResponseSchema,
+  GetPersonalAccessTokenResponseSchema,
+  GetProjectDevResponse,
+  WhoAmIResponseSchema,
+  CreateBackgroundWorkerResponse
+} from "@trigger.dev/core/v3";
+var ApiClient = class {
+  constructor(apiURL, accessToken) {
+    this.apiURL = apiURL;
+    this.accessToken = accessToken;
+  }
+  async createAuthorizationCode() {
+    return zodfetch(
+      CreateAuthorizationCodeResponseSchema,
+      `${this.apiURL}/api/v1/authorization-code`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  async getPersonalAccessToken(authorizationCode) {
+    return zodfetch(GetPersonalAccessTokenResponseSchema, `${this.apiURL}/api/v1/token`, {
+      method: "POST",
+      body: JSON.stringify({
+        authorizationCode
+      })
+    });
+  }
+  async whoAmI() {
+    if (!this.accessToken) {
+      throw new Error("whoAmI: No access token");
+    }
+    return zodfetch(WhoAmIResponseSchema, `${this.apiURL}/api/v2/whoami`, {
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async createBackgroundWorker(projectRef, body) {
+    if (!this.accessToken) {
+      throw new Error("indexProject: No access token");
+    }
+    return zodfetch(
+      CreateBackgroundWorkerResponse,
+      `${this.apiURL}/api/v1/projects/${projectRef}/background-workers`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  async getProjectDevEnv({ projectRef }) {
+    if (!this.accessToken) {
+      throw new Error("getProjectDevEnv: No access token");
+    }
+    return zodfetch(GetProjectDevResponse, `${this.apiURL}/api/v1/projects/${projectRef}/dev`, {
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+async function zodfetch(schema, url, requestInit) {
+  try {
+    const response = await fetch(url, requestInit);
+    if ((!requestInit || requestInit.method === "GET") && response.status === 404) {
+      return {
+        success: false,
+        error: `404: ${response.statusText}`
+      };
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.json();
+      if (!body.error) {
+        return { success: false, error: "Something went wrong" };
+      }
+      return { success: false, error: body.error };
+    }
+    if (response.status !== 200) {
+      return {
+        success: false,
+        error: `Failed to fetch ${url}, got status code ${response.status}`
+      };
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return { success: true, data: parsedResult.data };
+    }
+    if ("error" in jsonBody) {
+      return {
+        success: false,
+        error: typeof jsonBody.error === "string" ? jsonBody.error : JSON.stringify(jsonBody.error)
+      };
+    }
+    return { success: false, error: parsedResult.error.message };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : JSON.stringify(error)
+    };
+  }
+}
+
+// src/consts.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var distPath = path.dirname(__filename);
+var PKG_ROOT = path.join(distPath, "../");
+var COMMAND_NAME = "trigger.dev";
+var CLOUD_API_URL = "https://api.trigger.dev";
+
+// src/dev/backgroundWorker.ts
+import {
+  ZodMessageHandler,
+  ZodMessageSender,
+  childToWorkerMessages,
+  workerToChildMessages
+} from "@trigger.dev/core/v3";
+import chalk2 from "chalk";
+import { Evt } from "evt";
+import { fork } from "node:child_process";
+import { readFileSync } from "node:fs";
+import nodePath from "node:path";
+import { SourceMapConsumer } from "source-map";
+import terminalLink from "terminal-link";
+
+// src/utilities/logger.ts
+import { format } from "node:util";
+import chalk from "chalk";
+import CLITable from "cli-table3";
+import { formatMessagesSync } from "esbuild";
+
+// src/utilities/getEnvironmentVariableFactory.ts
+function getEnvironmentVariableFactory({
+  variableName,
+  deprecatedName,
+  defaultValue
+}) {
+  let hasWarned = false;
+  return () => {
+    if (process.env[variableName]) {
+      return process.env[variableName];
+    } else if (deprecatedName && process.env[deprecatedName]) {
+      if (!hasWarned) {
+        hasWarned = true;
+        logger.warn(
+          `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
+        );
+      }
+      return process.env[deprecatedName];
+    } else {
+      return defaultValue?.();
+    }
+  };
+}
+
+// src/utilities/logger.ts
+var LOGGER_LEVELS = {
+  none: -1,
+  error: 0,
+  warn: 1,
+  info: 2,
+  log: 3,
+  debug: 4
+};
+var LOGGER_LEVEL_FORMAT_TYPE_MAP = {
+  error: "error",
+  warn: "warning",
+  info: void 0,
+  log: void 0,
+  debug: void 0
+};
+var getLogLevelFromEnv = getEnvironmentVariableFactory({
+  variableName: "TRIGGER_LOG_LEVEL"
+});
+function getLoggerLevel() {
+  const fromEnv = getLogLevelFromEnv()?.toLowerCase();
+  if (fromEnv !== void 0) {
+    if (fromEnv in LOGGER_LEVELS)
+      return fromEnv;
+    const expected = Object.keys(LOGGER_LEVELS).map((level) => `"${level}"`).join(" | ");
+    console.warn(
+      `Unrecognised WRANGLER_LOG value ${JSON.stringify(
+        fromEnv
+      )}, expected ${expected}, defaulting to "log"...`
+    );
+  }
+  return "log";
+}
+var Logger = class {
+  constructor() {
+  }
+  loggerLevel = getLoggerLevel();
+  columns = process.stdout.columns;
+  debug = (...args) => this.doLog("debug", args);
+  debugWithSanitization = (label, ...args) => {
+    this.doLog("debug", [label, ...args]);
+  };
+  info = (...args) => this.doLog("info", args);
+  log = (...args) => this.doLog("log", args);
+  warn = (...args) => this.doLog("warn", args);
+  error = (...args) => this.doLog("error", args);
+  table(data) {
+    const keys = data.length === 0 ? [] : Object.keys(data[0]);
+    const t = new CLITable({
+      head: keys,
+      style: {
+        head: chalk.level ? ["blue"] : [],
+        border: chalk.level ? ["gray"] : []
+      }
+    });
+    t.push(...data.map((row) => keys.map((k) => row[k])));
+    return this.doLog("log", [t.toString()]);
+  }
+  doLog(messageLevel, args) {
+    const message = this.formatMessage(messageLevel, format(...args));
+    if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
+      console[messageLevel](message);
+    }
+  }
+  formatMessage(level, message) {
+    const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
+    if (kind) {
+      const [firstLine, ...otherLines] = message.split("\n");
+      const notes = otherLines.length > 0 ? otherLines.map((text) => ({ text })) : void 0;
+      return formatMessagesSync([{ text: firstLine, notes }], {
+        color: true,
+        kind,
+        terminalWidth: this.columns
+      })[0];
+    } else {
+      return message;
+    }
+  }
+};
+var logger = new Logger();
+
+// src/dev/backgroundWorker.ts
+var BackgroundWorkerCoordinator = class {
+  constructor(baseURL) {
+    this.baseURL = baseURL;
+    this.onTaskCompleted.attach(async ({ completion, execution }) => {
+      await this.#notifyWorkersOfTaskCompletion(completion, execution);
+    });
+  }
+  onTaskCompleted = new Evt();
+  onWorkerRegistered = new Evt();
+  onWorkerDeprecated = new Evt();
+  _backgroundWorkers = /* @__PURE__ */ new Map();
+  _records = /* @__PURE__ */ new Map();
+  async #notifyWorkersOfTaskCompletion(completion, execution) {
+    for (const worker of this._backgroundWorkers.values()) {
+      await worker.handleTaskRunCompletion(completion, execution);
+    }
+  }
+  get currentWorkers() {
+    return Array.from(this._backgroundWorkers.entries()).map(([id, worker]) => ({
+      id,
+      worker,
+      record: this._records.get(id)
+    }));
+  }
+  async registerWorker(record, worker) {
+    for (const [workerId, existingWorker] of this._backgroundWorkers.entries()) {
+      if (workerId === record.id) {
+        continue;
+      }
+      this.onWorkerDeprecated.post({ worker: existingWorker, id: workerId });
+    }
+    this._backgroundWorkers.set(record.id, worker);
+    this._records.set(record.id, record);
+    this.onWorkerRegistered.post({ worker, id: record.id, record });
+  }
+  close() {
+    for (const worker of this._backgroundWorkers.values()) {
+      worker.close();
+    }
+    this._backgroundWorkers.clear();
+    this._records.clear();
+  }
+  async handleMessage(id, message) {
+    switch (message.type) {
+      case "EXECUTE_RUNS": {
+        await Promise.all(message.payloads.map((payload) => this.#executeTaskRun(id, payload)));
+      }
+    }
+  }
+  async #executeTaskRun(id, payload) {
+    const worker = this._backgroundWorkers.get(id);
+    if (!worker) {
+      logger.error(`Could not find worker ${id}`);
+      return;
+    }
+    const record = this._records.get(id);
+    if (!record) {
+      logger.error(`Could not find worker record ${id}`);
+      return;
+    }
+    const { execution } = payload;
+    const link = chalk2.bgBlueBright(
+      terminalLink("view logs", `${this.baseURL}/runs/${execution.run.id}`)
+    );
+    const workerPrefix = chalk2.green(`[worker:${record.version}]`);
+    const taskPrefix = chalk2.yellow(`[task:${execution.task.id}]`);
+    const runId = chalk2.blue(execution.run.id);
+    const attempt = chalk2.blue(`.${execution.attempt.number}`);
+    logger.log(`${workerPrefix}${taskPrefix} ${runId}${attempt} ${link}`);
+    const now = performance.now();
+    const completion = await worker.executeTaskRun(payload);
+    const elapsed = performance.now() - now;
+    const resultText = !completion.ok ? chalk2.red("error") : chalk2.green("success");
+    const errorText = !completion.ok ? `
+
+	${chalk2.bgRed("Error")} ${this.#formatErrorLog(completion.error)}` : "";
+    const elapsedText = chalk2.dim(`(${elapsed.toFixed(2)}ms)`);
+    logger.log(
+      `${workerPrefix}${taskPrefix} ${runId}${attempt} ${resultText} ${elapsedText} ${link}${errorText}`
+    );
+    this.onTaskCompleted.post({ completion, execution, worker, backgroundWorkerId: id });
+  }
+  #formatErrorLog(error) {
+    switch (error.type) {
+      case "INTERNAL_ERROR": {
+        return `Internal error: ${error.code}`;
+      }
+      case "STRING_ERROR": {
+        return error.raw;
+      }
+      case "CUSTOM_ERROR": {
+        return error.raw;
+      }
+      case "BUILT_IN_ERROR": {
+        return `${error.name === "Error" ? "" : `(${error.name})`} ${error.message}
+${error.stackTrace.split("\n").map((line) => `	  ${line}`).join("\n")}
+`;
+      }
+    }
+  }
+};
+var BackgroundWorker = class {
+  constructor(path6, params) {
+    this.path = path6;
+    this.params = params;
+    this._rawSourceMap = JSON.parse(readFileSync(`${path6}.map`, "utf-8"));
+  }
+  _rawSourceMap;
+  _initialized = false;
+  _handler = new ZodMessageHandler({
+    schema: childToWorkerMessages
+  });
+  _onTaskCompleted = new Evt();
+  _onClose = new Evt();
+  tasks = [];
+  metadata;
+  _taskExecutions = /* @__PURE__ */ new Map();
+  close() {
+    this._onClose.post();
+  }
+  async initialize() {
+    if (this._initialized) {
+      throw new Error("Worker already initialized");
+    }
+    let resolved = false;
+    this.tasks = await new Promise((resolve2, reject) => {
+      const child = fork(this.path, {
+        stdio: [
+          /*stdin*/
+          "ignore",
+          /*stdout*/
+          "pipe",
+          /*stderr*/
+          "pipe",
+          "ipc"
+        ],
+        env: {
+          ...this.params.env
+        }
+      });
+      const timeout = setTimeout(() => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        child.kill();
+        reject(new Error("Worker timed out"));
+      }, 1e3);
+      child.on("message", async (msg) => {
+        const message = this._handler.parseMessage(msg);
+        if (message.type === "TASKS_READY" && !resolved) {
+          clearTimeout(timeout);
+          resolved = true;
+          resolve2(message.payload.tasks);
+          child.kill();
+        }
+      });
+      child.stdout?.on("data", (data) => {
+        logger.log(data.toString());
+      });
+      child.stderr?.on("data", (data) => {
+        logger.error(data.toString());
+      });
+      child.on("exit", (code) => {
+        if (!resolved) {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(new Error(`Worker exited with code ${code}`));
+        }
+      });
+    });
+    this._initialized = true;
+  }
+  async handleTaskRunCompletion(completion, execution) {
+    this._onTaskCompleted.post({ completion, execution });
+  }
+  // We need to fork the process before we can execute any tasks
+  async executeTaskRun(payload) {
+    const metadata = this.metadata;
+    if (!metadata) {
+      throw new Error("Worker not registered");
+    }
+    const { execution, traceContext } = payload;
+    const child = fork(this.path, {
+      stdio: [
+        /*stdin*/
+        "ignore",
+        /*stdout*/
+        "pipe",
+        /*stderr*/
+        "pipe",
+        "ipc"
+      ],
+      env: {
+        ...this.params.env
+      }
+    });
+    const sender = new ZodMessageSender({
+      schema: workerToChildMessages,
+      sender: async (message) => {
+        if (!child.connected) {
+          return;
+        }
+        child.send(message);
+      }
+    });
+    const ctx = Evt.newCtx();
+    this._onTaskCompleted.attach(ctx, async (taskCompletion) => {
+      if (execution.attempt.id === taskCompletion.execution.attempt.id) {
+        return;
+      }
+      await sender.send("TASK_RUN_COMPLETED", taskCompletion);
+    });
+    this._onClose.attachOnce(ctx, () => {
+      child.kill();
+    });
+    let resolved = false;
+    let resolver;
+    let rejecter;
+    const promise = new Promise((resolve2, reject) => {
+      resolver = resolve2;
+      rejecter = reject;
+    });
+    child.on("message", async (msg) => {
+      const message = this._handler.parseMessage(msg);
+      if (message.type === "TASK_RUN_COMPLETED") {
+        resolved = true;
+        resolver(message.payload.result);
+        this._onTaskCompleted.detach(ctx);
+        this._onClose.detach(ctx);
+        await sender.send("CLEANUP", { flush: true });
+      } else if (message.type === "READY_TO_DISPOSE") {
+        if (!child.killed) {
+          child.kill();
+        }
+      }
+    });
+    child.on("exit", (code) => {
+      if (!resolved) {
+        resolved = true;
+        this._onTaskCompleted.detach(ctx);
+        this._onClose.detach(ctx);
+        rejecter(new Error(`Worker exited with code ${code}`));
+      }
+    });
+    child.stdout?.on("data", (data) => {
+      logger.log(
+        `[${metadata.version}][${execution.run.id}.${execution.attempt.number}] ${data.toString()}`
+      );
+    });
+    await sender.send("EXECUTE_TASK_RUN", { execution, traceContext, metadata });
+    const result = await promise;
+    if (result.ok) {
+      return result;
+    }
+    const error = result.error;
+    if (error.type === "BUILT_IN_ERROR") {
+      const mappedError = await this.#correctError(error, execution);
+      return {
+        ...result,
+        error: mappedError
+      };
+    }
+    return result;
+  }
+  async #correctError(error, execution) {
+    return {
+      ...error,
+      stackTrace: await this.#correctErrorStackTrace(error.stackTrace, execution)
+    };
+  }
+  async #correctErrorStackTrace(stackTrace, execution) {
+    const lines = stackTrace.split("\n");
+    lines.shift();
+    return SourceMapConsumer.with(
+      this._rawSourceMap,
+      null,
+      (consumer) => lines.map((line) => this.#correctStackTraceLine(line, consumer, execution)).filter(Boolean).join("\n")
+    );
+  }
+  #correctStackTraceLine(line, consumer, execution) {
+    const regex = /at (.*?) \(file:\/\/(\/.*?\.mjs):(\d+):(\d+)\)/;
+    const match = regex.exec(line);
+    if (!match) {
+      return line;
+    }
+    const [_2, identifier, path6, lineNum, colNum] = match;
+    const originalPosition = consumer.originalPositionFor({
+      line: Number(lineNum),
+      column: Number(colNum)
+    });
+    if (!originalPosition.source) {
+      return line;
+    }
+    const { source, line: originalLine, column: originalColumn } = originalPosition;
+    if (this.#shouldFilterLine({ identifier, path: source })) {
+      return;
+    }
+    const sourcePath = path6 ? nodePath.relative(this.params.projectDir, nodePath.resolve(nodePath.dirname(path6), source)) : source;
+    return `at ${identifier === "Object.run" ? `${execution.task.exportName}.run` : identifier} (${sourcePath}:${originalLine}:${originalColumn})`;
+  }
+  #shouldFilterLine(line) {
+    const filename = nodePath.basename(line.path ?? "");
+    if (filename === "__entryPoint.ts") {
+      return true;
+    }
+    if (line.identifier === "async ZodMessageHandler.handleMessage") {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/utilities/initialBanner.ts
+import { spinner } from "@clack/prompts";
+import chalk4 from "chalk";
+import supportsColor from "supports-color";
+import checkForUpdate from "update-check";
+
+// src/utilities/colors.ts
+import chalk3 from "chalk";
+var green = "#4FFF54";
+var purple = "#735BF3";
+function chalkGrey(text) {
+  return chalk3.hex("#666")(text);
+}
+function chalkError(text) {
+  return chalk3.red(text);
+}
+function chalkSuccess(text) {
+  return chalk3.green(text);
+}
+function chalkLink(text) {
+  return chalk3.underline.blue(text);
+}
+function logo() {
+  return `${chalk3.hex(green).bold("Trigger")}${chalk3.hex(purple).bold(".dev")}`;
+}
+
+// src/utilities/getVersion.ts
+import path2 from "path";
+
+// src/utilities/fileSystem.ts
+import fsSync from "fs";
+import fsModule, { writeFile } from "fs/promises";
+async function pathExists(path6) {
+  return fsSync.existsSync(path6);
+}
+async function writeJSONFile(path6, json) {
+  await writeFile(path6, JSON.stringify(json, null, 2));
+}
+function readJSONFileSync(path6) {
+  const fileContents = fsSync.readFileSync(path6, "utf8");
+  return JSON.parse(fileContents);
+}
+
+// src/utilities/getVersion.ts
+function getVersion() {
+  const packageJsonPath = path2.join(PKG_ROOT, "package.json");
+  const packageJsonContent = readJSONFileSync(packageJsonPath);
+  return packageJsonContent.version ?? "1.0.0";
+}
+
+// src/utilities/initialBanner.ts
+async function printInitialBanner(performUpdateCheck = true) {
+  const packageVersion = getVersion();
+  const text = `
+${logo()} ${chalkGrey(`(${packageVersion})`)}
+`;
+  logger.info(text);
+  let maybeNewVersion;
+  if (performUpdateCheck) {
+    const loadingSpinner = spinner();
+    loadingSpinner.start("Checking for updates");
+    maybeNewVersion = await updateCheck();
+    if (maybeNewVersion !== void 0) {
+      loadingSpinner.stop(`Update available ${chalk4.green(maybeNewVersion)}`);
+      const currentMajor = parseInt(packageVersion.split(".")[0]);
+      const newMajor = parseInt(maybeNewVersion.split(".")[0]);
+      if (newMajor > currentMajor) {
+        logger.warn(
+          `Please update to the latest version of \`trigger.dev\` to prevent critical errors.
+Run \`npm install --save-dev trigger.dev@${newMajor}\` to update to the latest version.
+After installation, run Trigger.dev with \`npx trigger.dev\`.`
+        );
+      }
+    } else {
+      loadingSpinner.stop("On latest version");
+    }
+  }
+}
+async function printStandloneInitialBanner(performUpdateCheck = true) {
+  const packageVersion = getVersion();
+  let text = `
+${logo()} ${chalkGrey(`${packageVersion}`)}`;
+  if (performUpdateCheck) {
+    const maybeNewVersion = await updateCheck();
+    if (maybeNewVersion !== void 0) {
+      text = `${text} (update available ${chalk4.green(maybeNewVersion)})`;
+    }
+  }
+  logger.log(
+    text + "\n" + (supportsColor.stdout ? chalk4.hex(green)("-".repeat(54)) : "-".repeat(54))
+  );
+}
+async function doUpdateCheck() {
+  let update = null;
+  try {
+    update = await checkForUpdate(package_default, {
+      distTag: package_default.version.startsWith("0.0.0") ? "beta" : "latest"
+    });
+  } catch (err) {
+  }
+  return update?.latest;
+}
+var updateCheckPromise;
+function updateCheck() {
+  return updateCheckPromise ??= doUpdateCheck();
+}
+
+// src/utilities/configFiles.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import path3 from "node:path";
+
+// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/esm-wrapper/mod.esm.js
+var mod_esm_exports = {};
+__export(mod_esm_exports, {
+  default: () => mod_esm_default
+});
+var import_mod_cjs = __toESM(require_mod_cjs3(), 1);
+__reExport(mod_esm_exports, __toESM(require_mod_cjs3(), 1));
+var mod_esm_default = import_mod_cjs.default;
+
+// src/utilities/configFiles.ts
+import { z } from "zod";
+function getGlobalConfigFolderPath() {
+  const configDir = mod_esm_default(".trigger").config();
+  return configDir;
+}
+var UserAuthConfigSchema = z.object({
+  accessToken: z.string().optional(),
+  apiUrl: z.string().optional()
+});
+function getAuthConfigFilePath() {
+  return path3.join(getGlobalConfigFolderPath(), "config", "default.json");
+}
+function writeAuthConfigFile(config) {
+  const authConfigFilePath = getAuthConfigFilePath();
+  mkdirSync(path3.dirname(authConfigFilePath), {
+    recursive: true
+  });
+  writeFileSync(path3.join(authConfigFilePath), JSON.stringify(config), {
+    encoding: "utf-8"
+  });
+}
+function readAuthConfigFile() {
+  try {
+    const authConfigFilePath = getAuthConfigFilePath();
+    const json = readJSONFileSync(authConfigFilePath);
+    const parsed = UserAuthConfigSchema.parse(json);
+    return parsed;
+  } catch (error) {
+    logger.debug(`Error reading auth config file: ${error}`);
+    return void 0;
+  }
+}
+
+// src/utilities/session.ts
+async function isLoggedIn() {
+  const config = readAuthConfigFile();
+  if (!config?.accessToken || !config?.apiUrl) {
+    return { ok: false, error: "You must login first" };
+  }
+  const apiClient2 = new ApiClient(config.apiUrl, config.accessToken);
+  const userData = await apiClient2.whoAmI();
+  if (!userData.success) {
+    return {
+      ok: false,
+      error: userData.error
+    };
+  }
+  return {
+    ok: true,
+    config: {
+      apiUrl: config.apiUrl,
+      accessToken: config.accessToken
+    }
+  };
+}
+
+// src/cli/common.ts
+import { z as z2 } from "zod";
+var CommonCommandOptions = z2.object({
+  logLevel: z2.enum(["debug", "info", "log", "warn", "error", "none"]).default("log")
+});
+
+// src/commands/dev.tsx
+var CONFIG_FILES = ["trigger.config.js", "trigger.config.mjs"];
+var ConfigSchema = z3.object({
+  project: z3.string(),
+  triggerDirectories: z3.string().array().optional(),
+  triggerUrl: z3.string().optional(),
+  projectDir: z3.string().optional()
+});
+var apiClient;
+var DevCommandOptions = CommonCommandOptions;
+function configureDevCommand(program2) {
+  program2.command("dev").description("Run your Trigger.dev tasks locally").argument("[path]", "The path to the project", ".").option(
+    "-l, --log-level <level>",
+    "The log level to use (debug, info, log, warn, error, none)",
+    "log"
+  ).action(async (path6, options) => {
+    try {
+      await devCommand(path6, options);
+    } catch (e) {
+      throw e;
+    }
+  });
+}
+async function devCommand(dir, anyOptions) {
+  const options = DevCommandOptions.safeParse(anyOptions);
+  if (!options.success) {
+    throw new Error(`Invalid options: ${options.error}`);
+  }
+  const authorization = await isLoggedIn();
+  if (!authorization.ok) {
+    logger.error("You must login first. Use `trigger.dev login` to login.");
+    process.exitCode = 1;
+    return;
+  }
+  let watcher;
+  try {
+    const devInstance = await startDev(dir, options.data, authorization.config);
+    watcher = devInstance.watcher;
+    const { waitUntilExit } = devInstance.devReactElement;
+    await waitUntilExit();
+  } finally {
+    await watcher?.close();
+  }
+}
+async function startDev(dir, options, authorization) {
+  let watcher;
+  let rerender;
+  try {
+    if (options.logLevel) {
+      logger.loggerLevel = options.logLevel;
+    }
+    await printStandloneInitialBanner(true);
+    const configPath = await getConfigPath(dir);
+    let config = await readConfig(configPath);
+    watcher = watch(configPath, {
+      persistent: true
+    }).on("change", async (_event) => {
+      config = await readConfig(configPath);
+      logger.log(`${basename(configPath)} changed...`);
+      logger.debug("New config", { config });
+      rerender(await getDevReactElement(config, authorization));
+    });
+    async function getDevReactElement(configParam, authorization2) {
+      const accessToken = authorization2.accessToken;
+      const apiUrl = authorization2.apiUrl;
+      apiClient = new ApiClient(apiUrl, accessToken);
+      const devEnv = await apiClient.getProjectDevEnv({ projectRef: config.project });
+      if (!devEnv.success) {
+        throw new Error(devEnv.error);
+      }
+      const environmentClient = new ApiClient(apiUrl, devEnv.data.apiKey);
+      return /* @__PURE__ */ React.createElement(
+        DevUI,
+        {
+          config: configParam,
+          apiUrl,
+          apiKey: devEnv.data.apiKey,
+          environmentClient,
+          projectName: devEnv.data.name
+        }
+      );
+    }
+    const devReactElement = render(await getDevReactElement(config, authorization));
+    rerender = devReactElement.rerender;
+    return {
+      devReactElement,
+      watcher,
+      stop: async () => {
+        devReactElement.unmount();
+        await watcher?.close();
+      }
+    };
+  } catch (e) {
+    await watcher?.close();
+    throw e;
+  }
+}
+function useDev({ config, apiUrl, apiKey, environmentClient, projectName }) {
+  useEffect(() => {
+    const websocketUrl = new URL(apiUrl);
+    websocketUrl.protocol = websocketUrl.protocol.replace("http", "ws");
+    websocketUrl.pathname = `/ws`;
+    const websocket = new WebSocket(websocketUrl.href, [], {
+      WebSocket: WebsocketFactory(apiKey),
+      connectionTimeout: 1e4,
+      maxRetries: 6
+    });
+    websocket.addEventListener("open", (foo) => {
+    });
+    websocket.addEventListener("close", (event) => {
+    });
+    websocket.addEventListener("error", (event) => {
+    });
+    const sender = new ZodMessageSender2({
+      schema: clientWebsocketMessages,
+      sender: async (message) => {
+        websocket?.send(JSON.stringify(message));
+      }
+    });
+    const backgroundWorkerCoordinator = new BackgroundWorkerCoordinator(
+      `${apiUrl}/projects/v3/${config.project}`
+    );
+    backgroundWorkerCoordinator.onTaskCompleted.attach(
+      async ({ backgroundWorkerId, completion }) => {
+        await sender.send("BACKGROUND_WORKER_MESSAGE", {
+          backgroundWorkerId,
+          data: {
+            type: "TASK_RUN_COMPLETED",
+            completion
+          }
+        });
+      }
+    );
+    backgroundWorkerCoordinator.onWorkerRegistered.attach(async ({ id, worker, record }) => {
+      await sender.send("READY_FOR_TASKS", {
+        backgroundWorkerId: id
+      });
+    });
+    backgroundWorkerCoordinator.onWorkerDeprecated.attach(async ({ id }) => {
+      await sender.send("WORKER_DEPRECATED", {
+        backgroundWorkerId: id
+      });
+    });
+    websocket.addEventListener("message", async (event) => {
+      const data = JSON.parse(
+        typeof event.data === "string" ? event.data : new TextDecoder("utf-8").decode(event.data)
+      );
+      const messageHandler = new ZodMessageHandler2({
+        schema: serverWebsocketMessages,
+        messages: {
+          SERVER_READY: async (payload) => {
+          },
+          BACKGROUND_WORKER_MESSAGE: async (payload) => {
+            await backgroundWorkerCoordinator.handleMessage(
+              payload.backgroundWorkerId,
+              payload.data
+            );
+          }
+        }
+      });
+      await messageHandler.handleMessage(data);
+    });
+    let ctx;
+    async function runBuild() {
+      if (ctx) {
+        await ctx.cancel();
+        await ctx.dispose();
+      }
+      let latestWorkerContentHash;
+      const taskFiles = await gatherTaskFiles(config);
+      const workerFacade = readFileSync2(
+        new URL(importResolve("./worker-facade.js", import.meta.url)).href.replace("file://", ""),
+        "utf-8"
+      );
+      const entryPointContents = workerFacade.replace(
+        "__TASKS__",
+        createTaskFileImports(taskFiles)
+      );
+      let firstBuild = true;
+      logger.log(chalk5.dim("\u2394 Building background worker..."));
+      ctx = await context({
+        stdin: {
+          contents: entryPointContents,
+          resolveDir: process.cwd(),
+          sourcefile: "__entryPoint.ts"
+        },
+        bundle: true,
+        metafile: true,
+        write: false,
+        minify: false,
+        sourcemap: true,
+        logLevel: "silent",
+        platform: "node",
+        format: "esm",
+        target: ["node18", "es2020"],
+        outdir: "out",
+        define: {
+          TRIGGER_API_URL: `"${config.triggerUrl}"`
+        },
+        banner: {
+          js: "import { createRequire } from 'module';const require = createRequire(import.meta.url);"
+        },
+        plugins: [
+          {
+            name: "trigger.dev v3",
+            setup(build) {
+              build.onEnd(async (result) => {
+                if (result.errors.length > 0)
+                  return;
+                if (!result || !result.outputFiles) {
+                  logger.error("Build failed: no result");
+                  return;
+                }
+                if (!firstBuild) {
+                  logger.log(chalk5.dim("\u2394 Rebuilding background worker..."));
+                }
+                const metaOutputKey = join("out", `stdin.js`);
+                const metaOutput = result.metafile.outputs[metaOutputKey];
+                if (!metaOutput) {
+                  throw new Error(`Could not find metafile`);
+                }
+                const outputFileKey = join(config.projectDir, metaOutputKey);
+                const outputFile = result.outputFiles.find((file) => file.path === outputFileKey);
+                if (!outputFile) {
+                  throw new Error(
+                    `Could not find output file for entry point ${metaOutput.entryPoint}`
+                  );
+                }
+                const sourceMapFileKey = join(config.projectDir, `${metaOutputKey}.map`);
+                const sourceMapFile = result.outputFiles.find(
+                  (file) => file.path === sourceMapFileKey
+                );
+                if (!sourceMapFile) {
+                  throw new Error(
+                    `Could not find source map file for entry point ${metaOutput.entryPoint}`
+                  );
+                }
+                const md5Hasher = createHash("md5");
+                md5Hasher.update(Buffer.from(outputFile.contents.buffer));
+                const contentHash = md5Hasher.digest("hex");
+                if (latestWorkerContentHash === contentHash) {
+                  logger.log(chalk5.dim("\u2394 No changes detected, skipping build..."));
+                  logger.debug(`No changes detected, skipping build`);
+                  return;
+                }
+                const fullPath = join(config.projectDir, ".trigger", `${contentHash}.mjs`);
+                await fs.promises.mkdir(dirname(fullPath), { recursive: true });
+                await fs.promises.writeFile(fullPath, outputFile.text);
+                const sourceMapPath = `${fullPath}.map`;
+                await fs.promises.writeFile(sourceMapPath, sourceMapFile.text);
+                const backgroundWorker = new BackgroundWorker(fullPath, {
+                  projectDir: config.projectDir,
+                  env: {
+                    TRIGGER_API_URL: apiUrl,
+                    TRIGGER_API_KEY: apiKey
+                  }
+                });
+                await backgroundWorker.initialize();
+                latestWorkerContentHash = contentHash;
+                let packageVersion;
+                const taskResources = [];
+                if (!backgroundWorker.tasks) {
+                  throw new Error(`Background Worker started without tasks`);
+                }
+                for (const task of backgroundWorker.tasks) {
+                  taskResources.push({
+                    id: task.id,
+                    filePath: task.filePath,
+                    exportName: task.exportName
+                  });
+                  packageVersion = task.packageVersion;
+                }
+                if (!packageVersion) {
+                  throw new Error(`Background Worker started without package version`);
+                }
+                const backgroundWorkerBody = {
+                  localOnly: true,
+                  metadata: {
+                    packageVersion,
+                    // This is a hack to get around the funky node16 typescript module resolution issue
+                    cliPackageVersion: version,
+                    tasks: taskResources,
+                    contentHash
+                  }
+                };
+                const backgroundWorkerRecord = await environmentClient.createBackgroundWorker(
+                  config.project,
+                  backgroundWorkerBody
+                );
+                if (!backgroundWorkerRecord.success) {
+                  throw new Error(backgroundWorkerRecord.error);
+                }
+                backgroundWorker.metadata = backgroundWorkerRecord.data;
+                if (firstBuild) {
+                  logger.log(
+                    chalk5.green(
+                      `Background worker started (${backgroundWorkerRecord.data.version})`
+                    )
+                  );
+                } else {
+                  logger.log(
+                    chalk5.dim(`Background worker rebuilt (${backgroundWorkerRecord.data.version})`)
+                  );
+                }
+                firstBuild = false;
+                await backgroundWorkerCoordinator.registerWorker(
+                  backgroundWorkerRecord.data,
+                  backgroundWorker
+                );
+              });
+            }
+          }
+        ]
+      });
+      await ctx.watch();
+    }
+    const throttle = pThrottle({
+      limit: 2,
+      interval: 1e3
+    });
+    const throttledRebuild = throttle(runBuild);
+    const taskFileWatcher = watch(
+      config.triggerDirectories.map((triggerDir) => `${triggerDir}/*.ts`),
+      {
+        ignoreInitial: true
+      }
+    );
+    taskFileWatcher.on("add", async (path6) => {
+      throttledRebuild().catch((error) => {
+        logger.error(error);
+      });
+    });
+    taskFileWatcher.on("unlink", async (path6) => {
+      throttledRebuild().catch((error) => {
+        logger.error(error);
+      });
+    });
+    throttledRebuild().catch((error) => {
+      logger.error(error);
+    });
+    return () => {
+      logger.debug(`Shutting down dev session for ${config.project}`);
+      taskFileWatcher.close();
+      websocket?.close();
+      backgroundWorkerCoordinator.close();
+      ctx?.dispose().catch((error) => {
+        console.error(error);
+      });
+    };
+  }, [config, apiUrl, apiKey, environmentClient]);
+}
+function DevUI(props) {
+  return /* @__PURE__ */ React.createElement(Suspense, null, /* @__PURE__ */ React.createElement(DevUIImp, { ...props }));
+}
+function DevUIImp(props) {
+  const dev = useDev(props);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(HotKeys, null));
+}
+function useHotkeys() {
+  const { exit } = useApp();
+  useInput(async (input, key) => {
+    if (key.return) {
+      console.log("");
+      return;
+    }
+    switch (input.toLowerCase()) {
+      case "c":
+        console.clear();
+        console.log();
+        break;
+      case "b": {
+        break;
+      }
+      case "q":
+      case "x":
+        exit();
+        break;
+      default:
+        break;
+    }
+  });
+}
+function HotKeys() {
+  useHotkeys();
+  return /* @__PURE__ */ React.createElement(Box, { borderStyle: "round", paddingLeft: 1, paddingRight: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "[b]"), /* @__PURE__ */ React.createElement(Text, null, " open a browser, "), /* @__PURE__ */ React.createElement(Text, { bold: true }, "[c]"), /* @__PURE__ */ React.createElement(Text, null, " clear console, "), /* @__PURE__ */ React.createElement(Text, { bold: true }, "[x]"), /* @__PURE__ */ React.createElement(Text, null, " to exit"));
+}
+function WebsocketFactory(apiKey) {
+  return class extends wsWebSocket {
+    constructor(address, options) {
+      super(address, { ...options ?? {}, headers: { Authorization: `Bearer ${apiKey}` } });
+    }
+  };
+}
+function createTaskFileImports(taskFiles) {
+  return taskFiles.map(
+    (taskFile) => `import * as ${taskFile.importName} from "./${taskFile.importPath}"; TaskFileImports["${taskFile.importName}"] = ${taskFile.importName}; TaskFiles["${taskFile.importName}"] = ${JSON.stringify(
+      taskFile
+    )};`
+  ).join("\n");
+}
+async function gatherTaskFiles(config) {
+  const taskFiles = [];
+  for (const triggerDir of config.triggerDirectories) {
+    const files = await fs.promises.readdir(triggerDir, { withFileTypes: true });
+    for (const file of files) {
+      if (!file.isFile())
+        continue;
+      if (!file.name.endsWith(".js") && !file.name.endsWith(".ts"))
+        continue;
+      const fullPath = join(triggerDir, file.name);
+      const filePath = relative(config.projectDir, fullPath);
+      const importPath = filePath.replace(/\.(js|ts)$/, "");
+      const importName = importPath.replace(/\//g, "_");
+      taskFiles.push({ triggerDir, importPath, importName, filePath });
+    }
+  }
+  return taskFiles;
+}
+async function getConfigPath(dir) {
+  const path6 = await findUp(CONFIG_FILES, { cwd: dir });
+  if (!path6) {
+    throw new Error("No config file found.");
+  }
+  return path6;
+}
+async function readConfig(path6) {
+  try {
+    const userConfigModule = await import(`${pathToFileURL(path6).href}?_ts=${Date.now()}`);
+    const rawConfig = await normalizeConfig(userConfigModule ? userConfigModule.default : {});
+    const config = ConfigSchema.parse(rawConfig);
+    return resolveConfig(path6, config);
+  } catch (error) {
+    console.error(`Failed to load config file at ${path6}`);
+    throw error;
+  }
+}
+async function resolveConfig(path6, config) {
+  if (!config.triggerDirectories) {
+    config.triggerDirectories = await findTriggerDirectories(path6);
+  }
+  config.triggerDirectories = resolveTriggerDirectories(config.triggerDirectories);
+  if (!config.triggerUrl) {
+    config.triggerUrl = CLOUD_API_URL;
+  }
+  if (!config.projectDir) {
+    config.projectDir = dirname(path6);
+  }
+  return config;
+}
+async function normalizeConfig(config) {
+  if (typeof config === "function") {
+    config = config();
+  }
+  return await config;
+}
+function resolveTriggerDirectories(dirs) {
+  return dirs.map((dir) => resolve(dir));
+}
+var IGNORED_DIRS = ["node_modules", ".git", "dist", "build"];
+async function findTriggerDirectories(filePath) {
+  const dirPath = dirname(filePath);
+  return getTriggerDirectories(dirPath);
+}
+async function getTriggerDirectories(dirPath) {
+  const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+  const triggerDirectories = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || IGNORED_DIRS.includes(entry.name))
+      continue;
+    const fullPath = join(dirPath, entry.name);
+    if (entry.name === "trigger") {
+      triggerDirectories.push(fullPath);
+    }
+    triggerDirectories.push(...await getTriggerDirectories(fullPath));
+  }
+  return triggerDirectories;
+}
+
+// src/commands/login.ts
+import { intro, log, outro, select, spinner as spinner3 } from "@clack/prompts";
+
+// ../../node_modules/.pnpm/open@10.0.3/node_modules/open/index.js
+import process6 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import childProcess from "node:child_process";
+import fs5, { constants as fsConstants } from "node:fs/promises";
+
+// ../../node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs4 from "node:fs";
+
+// ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+import fs3 from "node:fs";
+
+// ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+import fs2 from "node:fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs2.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs2.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs3.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// ../../node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    return fs4.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+  } catch {
+    return false;
+  }
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// ../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// ../../node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/index.js
+import { promisify as promisify4 } from "node:util";
+import process5 from "node:process";
+import { execFile as execFile4 } from "node:child_process";
+
+// ../../node_modules/.pnpm/default-browser-id@5.0.0/node_modules/default-browser-id/index.js
+import { promisify } from "node:util";
+import process3 from "node:process";
+import { execFile } from "node:child_process";
+var execFileAsync = promisify(execFile);
+async function defaultBrowserId() {
+  if (process3.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  return match?.groups.id ?? "com.apple.Safari";
+}
+
+// ../../node_modules/.pnpm/run-applescript@7.0.0/node_modules/run-applescript/index.js
+import process4 from "node:process";
+import { promisify as promisify2 } from "node:util";
+import { execFile as execFile2, execFileSync } from "node:child_process";
+var execFileAsync2 = promisify2(execFile2);
+async function runAppleScript(script, { humanReadableOutput = true } = {}) {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments]);
+  return stdout.trim();
+}
+
+// ../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+// ../../node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/windows.js
+import { promisify as promisify3 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+var execFileAsync3 = promisify3(execFile3);
+var windowsBrowserProgIds = {
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
+  // On macOS, it's "com.microsoft.edgemac"
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  // Newer Edge/Win10 releases
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
+};
+var UnknownBrowserError = class extends Error {
+};
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const browser = windowsBrowserProgIds[id];
+  if (!browser) {
+    throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+  }
+  return browser;
+}
+
+// ../../node_modules/.pnpm/default-browser@5.2.1/node_modules/default-browser/index.js
+var execFileAsync4 = promisify4(execFile4);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (process5.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process5.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process5.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+// ../../node_modules/.pnpm/open@10.0.3/node_modules/open/index.js
+var __dirname = path4.dirname(fileURLToPath2(import.meta.url));
+var localXdgOpenPath = path4.join(__dirname, "xdg-open");
+var { platform, arch } = process6;
+var getWslDrivesMountPoint = /* @__PURE__ */ (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs5.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {
+    }
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs5.readFile(configFilePath, { encoding: "utf8" });
+    const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+    if (!configMountPoint) {
+      return defaultMountPoint;
+    }
+    mountPoint = configMountPoint.groups.mountPoint.trim();
+    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+    return mountPoint;
+  };
+})();
+var pTryEach = async (array, mapper) => {
+  let latestError;
+  for (const item of array) {
+    try {
+      return await mapper(item);
+    } catch (error) {
+      latestError = error;
+    }
+  }
+  throw latestError;
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  if (Array.isArray(options.app)) {
+    return pTryEach(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return pTryEach(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      }
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "microsoft-edge.desktop": "edge"
+    };
+    const flags = {
+      chrome: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    const browser = await defaultBrowser2();
+    if (browser.id in ids) {
+      const browserName = ids[browser.id];
+      if (app === "browserPrivate") {
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+    const mountPoint = await getWslDrivesMountPoint();
+    command = is_wsl_default ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process6.env.SYSTEMROOT || process6.env.windir || "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+    cliArguments.push(
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand"
+    );
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    const encodedArguments = ["Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(`"\`"${app}\`""`);
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(`"${options.target}"`);
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = Buffer2.from(encodedArguments.join(" "), "utf16le").toString("base64");
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname || __dirname === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {
+      }
+      const useSystemXdgOpen = process6.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve2, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode > 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve2(subprocess);
+      });
+    });
+  }
+  subprocess.unref();
+  return subprocess;
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var apps = {};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+  darwin: "google chrome",
+  win32: "chrome",
+  linux: ["google-chrome", "google-chrome-stable", "chromium"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+  }
+}));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+  darwin: "firefox",
+  win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+  linux: "firefox"
+}, {
+  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+}));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+  darwin: "microsoft edge",
+  win32: "msedge",
+  linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, {
+  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+}));
+defineLazyProperty(apps, "browser", () => "browser");
+defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+var open_default = open;
+
+// ../../node_modules/.pnpm/p-retry@6.1.0/node_modules/p-retry/index.js
+var import_retry = __toESM(require_retry2(), 1);
+
+// ../../node_modules/.pnpm/is-network-error@1.0.0/node_modules/is-network-error/index.js
+var objectToString = Object.prototype.toString;
+var isError = (value) => objectToString.call(value) === "[object Error]";
+var errorMessages = /* @__PURE__ */ new Set([
+  "Failed to fetch",
+  // Chrome
+  "NetworkError when attempting to fetch resource.",
+  // Firefox
+  "The Internet connection appears to be offline.",
+  // Safari 16
+  "Load failed",
+  // Safari 17+
+  "Network request failed",
+  // `cross-fetch`
+  "fetch failed"
+  // Undici (Node.js)
+]);
+function isNetworkError(error) {
+  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid) {
+    return false;
+  }
+  if (error.message === "Load failed") {
+    return error.stack === void 0;
+  }
+  return errorMessages.has(error.message);
+}
+
+// ../../node_modules/.pnpm/p-retry@6.1.0/node_modules/p-retry/index.js
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var decorateErrorWithCounts = (error, attemptNumber, options) => {
+  const retriesLeft = options.retries - (attemptNumber - 1);
+  error.attemptNumber = attemptNumber;
+  error.retriesLeft = retriesLeft;
+  return error;
+};
+async function pRetry(input, options) {
+  return new Promise((resolve2, reject) => {
+    options = {
+      onFailedAttempt() {
+      },
+      retries: 10,
+      ...options
+    };
+    const operation = import_retry.default.operation(options);
+    const abortHandler = () => {
+      operation.stop();
+      reject(options.signal?.reason);
+    };
+    if (options.signal && !options.signal.aborted) {
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const cleanUp = () => {
+      options.signal?.removeEventListener("abort", abortHandler);
+      operation.stop();
+    };
+    operation.attempt(async (attemptNumber) => {
+      try {
+        const result = await input(attemptNumber);
+        cleanUp();
+        resolve2(result);
+      } catch (error) {
+        try {
+          if (!(error instanceof Error)) {
+            throw new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+          }
+          if (error instanceof AbortError) {
+            throw error.originalError;
+          }
+          if (error instanceof TypeError && !isNetworkError(error)) {
+            throw error;
+          }
+          await options.onFailedAttempt(decorateErrorWithCounts(error, attemptNumber, options));
+          if (!operation.retry(error)) {
+            throw operation.mainError();
+          }
+        } catch (finalError) {
+          decorateErrorWithCounts(finalError, attemptNumber, options);
+          cleanUp();
+          reject(finalError);
+        }
+      }
+    });
+  });
+}
+
+// src/commands/whoami.ts
+import { note, spinner as spinner2 } from "@clack/prompts";
+var WhoamiCommandOptions = CommonCommandOptions;
+function configureWhoamiCommand(program2) {
+  program2.command("whoami").description("display the current logged in user and project details").option(
+    "-l, --log-level <level>",
+    "The log level to use (debug, info, log, warn, error, none)",
+    "log"
+  ).action(async (options) => {
+    try {
+      await printInitialBanner();
+      await whoAmI(WhoamiCommandOptions.parse(options));
+    } catch (e) {
+      throw e;
+    }
+  });
+}
+async function whoAmI(options) {
+  if (options?.logLevel) {
+    logger.loggerLevel = options?.logLevel;
+  }
+  const loadingSpinner = spinner2();
+  loadingSpinner.start("Checking your account details");
+  const authentication = await isLoggedIn();
+  if (!authentication.ok) {
+    loadingSpinner.stop("You must login first. Use `trigger.dev login` to login.");
+    return {
+      success: false,
+      error: authentication.error
+    };
+  }
+  const apiClient2 = new ApiClient(authentication.config.apiUrl, authentication.config.accessToken);
+  const userData = await apiClient2.whoAmI();
+  if (!userData.success) {
+    loadingSpinner.stop("Error getting your account details");
+    logger.error(userData.error);
+    return {
+      success: false,
+      error: userData.error
+    };
+  }
+  loadingSpinner.stop("Retrieved your account details");
+  note(
+    `User ID: ${userData.data.userId}
+Email: ${userData.data.email}
+URL: ${chalkLink(authentication.config.apiUrl)}
+`,
+    "Account details"
+  );
+  return userData;
+}
+
+// src/commands/login.ts
+async function loginCommand(options) {
+  const result = ApiUrlOptionsSchema.safeParse(options);
+  if (!result.success) {
+    logger.error(result.error.message);
+    return;
+  }
+  return login(result.data.apiUrl);
+}
+async function login(apiUrl) {
+  const apiClient2 = new ApiClient(apiUrl);
+  intro("Logging in to Trigger.dev");
+  const existingAccessToken = readAuthConfigFile()?.accessToken;
+  if (existingAccessToken) {
+    const whoAmiI = await whoAmI();
+    const continueOption = await select({
+      message: "You are already logged in.",
+      options: [
+        {
+          value: false,
+          label: "Exit"
+        },
+        {
+          value: true,
+          label: "Login with a different account"
+        }
+      ],
+      initialValue: false
+    });
+    if (continueOption !== true) {
+      outro("Already logged in");
+      return {
+        success: true,
+        accessToken: existingAccessToken
+      };
+    }
+  }
+  const createAuthCodeSpinner = spinner3();
+  createAuthCodeSpinner.start("Creating authorition code");
+  const authorizationCodeResult = await apiClient2.createAuthorizationCode();
+  if (!authorizationCodeResult.success) {
+    createAuthCodeSpinner.stop(
+      `Failed to create authorization code
+${authorizationCodeResult.error}`
+    );
+    return {
+      success: false,
+      error: authorizationCodeResult.error
+    };
+  }
+  createAuthCodeSpinner.stop("Created authorization code");
+  log.step(
+    `Please visit the following URL to login:
+${chalkLink(authorizationCodeResult.data.url)}`
+  );
+  await open_default(authorizationCodeResult.data.url);
+  const getPersonalAccessTokenSpinner = spinner3();
+  getPersonalAccessTokenSpinner.start("Waiting for you to login");
+  try {
+    const indexResult = await pRetry(
+      () => getPersonalAccessToken(apiClient2, authorizationCodeResult.data.authorizationCode),
+      {
+        //this means we're polling, same distance between each attempt
+        factor: 1,
+        retries: 60,
+        minTimeout: 1e3
+      }
+    );
+    getPersonalAccessTokenSpinner.stop(`Logged in with token ${indexResult.obfuscatedToken}`);
+    writeAuthConfigFile({ accessToken: indexResult.token, apiUrl });
+    outro("Logged in successfully");
+    return {
+      success: true,
+      accessToken: indexResult.token
+    };
+  } catch (e) {
+    getPersonalAccessTokenSpinner.stop(`Failed to get access token`);
+    if (e instanceof AbortError) {
+      log.error(e.message);
+    }
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : JSON.stringify(e)
+    };
+  }
+}
+async function getPersonalAccessToken(apiClient2, authorizationCode) {
+  const token = await apiClient2.getPersonalAccessToken(authorizationCode);
+  if (!token.success) {
+    throw new AbortError(token.error);
+  }
+  if (!token.data.token) {
+    throw new Error("No token found yet");
+  }
+  return {
+    token: token.data.token.token,
+    obfuscatedToken: token.data.token.obfuscatedToken
+  };
+}
+
+// src/commands/logout.ts
+async function logoutCommand(options) {
+  const config = readAuthConfigFile();
+  if (!config?.accessToken) {
+    logger.info("You are already logged out");
+    return;
+  }
+  writeAuthConfigFile({ ...config, accessToken: void 0, apiUrl: void 0 });
+  logger.info("Logged out");
+}
+
+// src/commands/update.ts
+import { confirm, spinner as spinner5 } from "@clack/prompts";
+import { run } from "npm-check-updates";
+import path5 from "path";
+import { z as z4 } from "zod";
+
+// src/utilities/installDependencies.ts
+import { spinner as spinner4 } from "@clack/prompts";
+import chalk6 from "chalk";
+import { execa } from "execa";
+
+// src/utilities/getUserPackageManager.ts
+import pathModule from "path";
+async function getUserPackageManager(path6) {
+  try {
+    return await detectPackageManagerFromArtifacts(path6);
+  } catch (error) {
+    return detectPackageManagerFromCurrentCommand();
+  }
+}
+function detectPackageManagerFromCurrentCommand() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("yarn")) {
+      return "yarn";
+    } else if (userAgent.startsWith("pnpm")) {
+      return "pnpm";
+    } else {
+      return "npm";
+    }
+  } else {
+    return "npm";
+  }
+}
+async function detectPackageManagerFromArtifacts(path6) {
+  const packageFiles = [
+    { name: "yarn.lock", pm: "yarn" },
+    { name: "pnpm-lock.yaml", pm: "pnpm" },
+    { name: "package-lock.json", pm: "npm" },
+    { name: "npm-shrinkwrap.json", pm: "npm" }
+  ];
+  for (const { name, pm } of packageFiles) {
+    const exists = await pathExists(pathModule.join(path6, name));
+    if (exists) {
+      return pm;
+    }
+  }
+  throw new Error("Could not detect package manager from artifacts");
+}
+
+// src/utilities/installDependencies.ts
+async function installDependencies(projectDir) {
+  logger.info("Installing dependencies...");
+  const pkgManager = await getUserPackageManager(projectDir);
+  const installSpinner = await runInstallCommand(pkgManager, projectDir);
+  (installSpinner || spinner4()).stop(chalk6.green("Successfully installed dependencies!\n"));
+}
+async function runInstallCommand(pkgManager, projectDir) {
+  switch (pkgManager) {
+    case "npm":
+      await execa(pkgManager, ["install"], {
+        cwd: projectDir,
+        stderr: "inherit"
+      });
+      return null;
+    case "pnpm": {
+      const loadingSpinner = spinner4();
+      loadingSpinner.start("Running pnpm install...");
+      const pnpmSubprocess = execa(pkgManager, ["install"], {
+        cwd: projectDir,
+        stdout: "pipe"
+      });
+      await new Promise((res, rej) => {
+        pnpmSubprocess.stdout?.on("data", (data) => {
+          const text = data.toString();
+          if (text.includes("Progress")) {
+            loadingSpinner.message(text.includes("|") ? text.split(" | ")[1] ?? "" : text);
+          }
+        });
+        pnpmSubprocess.on("error", (e) => rej(e));
+        pnpmSubprocess.on("close", () => res());
+      });
+      return loadingSpinner;
+    }
+    case "yarn": {
+      const loadingSpinner = spinner4();
+      loadingSpinner.start("Running yarn...");
+      const yarnSubprocess = execa(pkgManager, [], {
+        cwd: projectDir,
+        stdout: "pipe"
+      });
+      await new Promise((res, rej) => {
+        yarnSubprocess.stdout?.on("data", (data) => {
+          loadingSpinner.message(data.toString());
+        });
+        yarnSubprocess.on("error", (e) => rej(e));
+        yarnSubprocess.on("close", () => res());
+      });
+      return loadingSpinner;
+    }
+  }
+}
+
+// src/commands/update.ts
+var UpdateCommandOptionsSchema = z4.object({
+  to: z4.string().optional()
+});
+async function updateCommand(projectPath, anyOptions) {
+  const loadingSpinner = spinner5();
+  loadingSpinner.start("Checking settings");
+  const parseRes = UpdateCommandOptionsSchema.safeParse(anyOptions);
+  if (!parseRes.success) {
+    loadingSpinner.stop(chalkError(parseRes.error.message));
+    return;
+  }
+  const options = parseRes.data;
+  const triggerDevPackage = "@trigger.dev";
+  const packageJSONPath = path5.join(projectPath, "package.json");
+  const packageData = readJSONFileSync(packageJSONPath);
+  if (!packageData) {
+    loadingSpinner.stop(chalkError("Couldn't load package.json"));
+    return;
+  }
+  loadingSpinner.message("Checking for updates");
+  const packageMaps = {};
+  const packageDependencies = packageData.dependencies || {};
+  const packageDevDependencies = packageData.devDependencies || {};
+  Object.keys(packageDependencies).forEach((i) => {
+    packageMaps[i] = { type: "dependencies", version: packageDependencies[i] };
+  });
+  Object.keys(packageDevDependencies).forEach((i) => {
+    packageMaps[i] = {
+      type: "devDependencies",
+      version: packageDevDependencies[i]
+    };
+  });
+  const targetVersion = getTargetVersion(options.to);
+  const ncuOptions = {
+    packageData,
+    upgrade: true,
+    jsonUpgraded: true,
+    target: targetVersion
+  };
+  const updatedDependencies = await run(ncuOptions);
+  if (!updatedDependencies) {
+    loadingSpinner.stop(chalkError("Couldn't update dependencies"));
+    return;
+  }
+  const ifUpdatedDependenciesIsPackageJSON = updatedDependencies.hasOwnProperty("dependencies") || updatedDependencies.hasOwnProperty("devDependencies");
+  const dependencies = updatedDependencies.dependencies || {};
+  const devDependencies = updatedDependencies.devDependencies || {};
+  const allDependencies = ifUpdatedDependenciesIsPackageJSON ? Object.keys({ ...dependencies, ...devDependencies }) : Object.keys(updatedDependencies);
+  const triggerPackages = allDependencies.filter((pkg) => pkg.startsWith(triggerDevPackage));
+  if (triggerPackages.length === 0) {
+    loadingSpinner.stop(chalkSuccess(`All @trigger.dev/* packages are already up to date.`));
+    return;
+  }
+  const packagesToUpdate = triggerPackages.filter((pkg) => updatedDependencies[pkg]);
+  if (packagesToUpdate.length === 0) {
+    loadingSpinner.stop(chalkSuccess(`All @trigger.dev/* packages are already up to date.`));
+    return;
+  }
+  let applyUpdates = targetVersion !== "latest";
+  if (targetVersion === "latest") {
+    applyUpdates = await hasUserConfirmed(packagesToUpdate, packageMaps, updatedDependencies);
+  }
+  if (applyUpdates) {
+    const newPackageJSON = packageData;
+    packagesToUpdate.forEach((packageName) => {
+      const tmp = packageMaps[packageName];
+      if (tmp) {
+        newPackageJSON[tmp.type][packageName] = updatedDependencies[packageName];
+      }
+    });
+    await writeJSONFile(packageJSONPath, newPackageJSON);
+    await installDependencies(projectPath);
+  }
+}
+function getTargetVersion(toVersion) {
+  if (!toVersion) {
+    return "latest";
+  }
+  return toVersion === "latest" ? "latest" : `@${toVersion}`;
+}
+async function hasUserConfirmed(packagesToUpdate, packageMaps, updatedDependencies) {
+  console.log("\nNewer versions found for the following packages:");
+  console.table(
+    packagesToUpdate.map((i) => ({
+      name: i,
+      old: packageMaps[i]?.version,
+      new: updatedDependencies[i]
+    }))
+  );
+  const shouldContinue = await confirm({
+    message: "Do you want to update these packages in package.json and re-install dependencies?"
+  });
+  return shouldContinue;
+}
+
+// src/cli/index.ts
+var program = new Command();
+var ApiUrlOptionsSchema = z5.object({
+  apiUrl: z5.string()
+});
+program.name(COMMAND_NAME).description("Create, run locally and deploy Trigger.dev background tasks.").version(getVersion(), "-v, --version", "Display the version number");
+program.command("login").description("Login with Trigger.dev so you can perform authenticated actions").option(
+  "-a, --api-url <value>",
+  "Override the API URL, defaults to https://api.trigger.dev",
+  "https://api.trigger.dev"
+).version(getVersion(), "-v, --version", "Display the version number").action(async (options) => {
+  try {
+    await printInitialBanner(false);
+    await loginCommand(options);
+  } catch (e) {
+    throw e;
+  }
+});
+program.command("logout").description("Logout of Trigger.dev").version(getVersion(), "-v, --version", "Display the version number").action(async (options) => {
+  try {
+    await printInitialBanner(false);
+    await logoutCommand(options);
+  } catch (e) {
+    throw e;
+  }
+});
+configureDevCommand(program);
+program.command("update").description(
+  "Updates all @trigger.dev/* packages to their latest compatible versions or the specified version"
+).argument("[path]", "The path to the directory that contains the package.json file", ".").option("-t, --to <version tag>", "The version to update to (ex: 2.1.4)", "latest").action(async (path6, options) => {
+  await printInitialBanner(false);
+  await updateCommand(path6, options);
+});
+configureWhoamiCommand(program);
+
+// src/index.ts
+var main = async () => {
+  await program.parseAsync();
+};
+main().catch((err) => {
+  if (err instanceof Error) {
+    logger.error(err);
+  } else {
+    logger.error("An unknown error has occurred. Please open an issue on github with the below:");
+    logger.error(err);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map