trigger.dev 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/index.js

@@ -57,7 +57,7 @@ var require_XDGAppPaths = __commonJS({
       return typeof t;
     }
     function Adapt(adapter_) {
-      var meta = adapter_.meta, path6 = adapter_.path, xdg = adapter_.xdg;
+      var meta = adapter_.meta, path7 = adapter_.path, xdg = adapter_.xdg;
       var XDGAppPaths_ = /* @__PURE__ */ function() {
         function XDGAppPaths_2(options_) {
           if (options_ === void 0) {
@@ -79,7 +79,7 @@ var require_XDGAppPaths = __commonJS({
             meta.mainFilename()
           ];
           var nameFallback = "$eval";
-          var name = path6.parse(((_c = namePriorityList.find(function(e) {
+          var name = path7.parse(((_c = namePriorityList.find(function(e) {
             return isString(e);
           })) !== null && _c !== void 0 ? _c : nameFallback) + suffix).name;
           XDGAppPaths.$name = function $name() {
@@ -98,28 +98,28 @@ var require_XDGAppPaths = __commonJS({
             return isIsolated(dirOptions) ? name : "";
           }
           XDGAppPaths.cache = function cache(dirOptions) {
-            return path6.join(xdg.cache(), finalPathSegment(dirOptions));
+            return path7.join(xdg.cache(), finalPathSegment(dirOptions));
           };
           XDGAppPaths.config = function config(dirOptions) {
-            return path6.join(xdg.config(), finalPathSegment(dirOptions));
+            return path7.join(xdg.config(), finalPathSegment(dirOptions));
           };
           XDGAppPaths.data = function data(dirOptions) {
-            return path6.join(xdg.data(), finalPathSegment(dirOptions));
+            return path7.join(xdg.data(), finalPathSegment(dirOptions));
           };
           XDGAppPaths.runtime = function runtime(dirOptions) {
-            return xdg.runtime() ? path6.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+            return xdg.runtime() ? path7.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
           };
           XDGAppPaths.state = function state(dirOptions) {
-            return path6.join(xdg.state(), finalPathSegment(dirOptions));
+            return path7.join(xdg.state(), finalPathSegment(dirOptions));
           };
           XDGAppPaths.configDirs = function configDirs(dirOptions) {
             return xdg.configDirs().map(function(s) {
-              return path6.join(s, finalPathSegment(dirOptions));
+              return path7.join(s, finalPathSegment(dirOptions));
             });
           };
           XDGAppPaths.dataDirs = function dataDirs(dirOptions) {
             return xdg.dataDirs().map(function(s) {
-              return path6.join(s, finalPathSegment(dirOptions));
+              return path7.join(s, finalPathSegment(dirOptions));
             });
           };
           return XDGAppPaths;
@@ -144,14 +144,14 @@ var require_XDG = __commonJS({
     exports.__esModule = true;
     exports.Adapt = void 0;
     function Adapt(adapter_) {
-      var env = adapter_.env, osPaths = adapter_.osPaths, path6 = adapter_.path;
+      var env = adapter_.env, osPaths = adapter_.osPaths, path7 = 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);
+        return val || path7.join.apply(path7, pathSegments);
       }
       var linux = function() {
         var cache = function() {
@@ -226,11 +226,11 @@ var require_XDG = __commonJS({
           XDG.state = extension.state;
           XDG.configDirs = function configDirs() {
             var pathList = env.get("XDG_CONFIG_DIRS");
-            return __spreadArray([extension.config()], pathList ? pathList.split(path6.delimiter) : []);
+            return __spreadArray([extension.config()], pathList ? pathList.split(path7.delimiter) : []);
           };
           XDG.dataDirs = function dataDirs() {
             var pathList = env.get("XDG_DATA_DIRS");
-            return __spreadArray([extension.data()], pathList ? pathList.split(path6.delimiter) : []);
+            return __spreadArray([extension.data()], pathList ? pathList.split(path7.delimiter) : []);
           };
           return XDG;
         }
@@ -257,13 +257,13 @@ var require_OSPaths = __commonJS({
       return !s;
     }
     function Adapt(adapter_) {
-      var env = adapter_.env, os2 = adapter_.os, path6 = adapter_.path;
+      var env = adapter_.env, os2 = adapter_.os, path7 = 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() {
+        var posix2 = function() {
           return normalizePath((typeof os2.homedir === "function" ? os2.homedir() : void 0) || env.get("HOME"));
         };
         var windows = function() {
@@ -271,19 +271,19 @@ var require_OSPaths = __commonJS({
             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
+            env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path7.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
           ];
           return normalizePath(priorityList.find(function(v) {
             return !isEmpty(v);
           }));
         };
-        return isWinOS ? windows() : posix();
+        return isWinOS ? windows() : posix2();
       }
       function temp() {
         function joinPathToBase(base, segments) {
-          return base ? path6.join.apply(path6, __spreadArray([base], segments)) : void 0;
+          return base ? path7.join.apply(path7, __spreadArray([base], segments)) : void 0;
         }
-        function posix() {
+        function posix2() {
           var fallback = "/tmp";
           var priorityList = [
             typeof os2.tmpdir === "function" ? os2.tmpdir() : void 0,
@@ -331,7 +331,7 @@ var require_OSPaths = __commonJS({
           });
           return v && normalizePath(v()) || fallback;
         }
-        return isWinOS ? windows() : posix();
+        return isWinOS ? windows() : posix2();
       }
       var OSPaths_ = /* @__PURE__ */ function() {
         function OSPaths_2() {
@@ -385,7 +385,7 @@ var require_node = __commonJS({
     exports.__esModule = true;
     exports.adapter = void 0;
     var os2 = __importStar(__require("os"));
-    var path6 = __importStar(__require("path"));
+    var path7 = __importStar(__require("path"));
     exports.adapter = {
       atImportPermissions: { env: true },
       env: {
@@ -394,7 +394,7 @@ var require_node = __commonJS({
         }
       },
       os: os2,
-      path: path6,
+      path: path7,
       process
     };
   }
@@ -447,7 +447,7 @@ var require_node2 = __commonJS({
     };
     exports.__esModule = true;
     exports.adapter = void 0;
-    var path6 = __importStar(__require("path"));
+    var path7 = __importStar(__require("path"));
     var os_paths_1 = __importDefault(require_mod_cjs());
     exports.adapter = {
       atImportPermissions: { env: true },
@@ -457,7 +457,7 @@ var require_node2 = __commonJS({
         }
       },
       osPaths: os_paths_1["default"],
-      path: path6,
+      path: path7,
       process
     };
   }
@@ -510,7 +510,7 @@ var require_node3 = __commonJS({
     };
     exports.__esModule = true;
     exports.adapter = void 0;
-    var path6 = __importStar(__require("path"));
+    var path7 = __importStar(__require("path"));
     var xdg_portable_1 = __importDefault(require_mod_cjs2());
     exports.adapter = {
       atImportPermissions: { env: true, read: true },
@@ -525,7 +525,7 @@ var require_node3 = __commonJS({
           return process.pkg ? process.execPath : void 0;
         }
       },
-      path: path6,
+      path: path7,
       process,
       xdg: xdg_portable_1["default"]
     };
@@ -777,30 +777,29 @@ var require_retry2 = __commonJS({
 import { Command as Command2 } from "commander";
 
 // src/commands/deploy.ts
-import { intro as intro3, log as log2, outro as outro3, spinner as spinner4 } from "@clack/prompts";
+import { intro as intro4, log as log5, outro as outro5 } from "@clack/prompts";
 import { depot } from "@depot/cli";
 import { context, trace as trace2 } from "@opentelemetry/api";
 import {
+  TaskMetadataFailedToParseData,
   detectDependencyVersion,
-  flattenAttributes as flattenAttributes2,
-  recordSpanException as recordSpanException4
+  flattenAttributes as flattenAttributes2
 } from "@trigger.dev/core/v3";
-import chalk4 from "chalk";
+import { recordSpanException as recordSpanException4 } from "@trigger.dev/core/v3/workers";
 import { Option as CommandOption } from "commander";
 import { build as build2 } from "esbuild";
 import { execa as execa2 } from "execa";
-import { resolve as importResolve } from "import-meta-resolve";
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
 import { copyFile, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, join as join4, relative as relative2 } from "node:path";
+import { dirname, join as join6, relative as relative3, posix } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
-import terminalLink from "terminal-link";
+import terminalLink2 from "terminal-link";
 import invariant from "tiny-invariant";
 import { z as z4 } from "zod";
 
 // package.json
-var version = "3.0.0-beta.2";
+var version = "3.0.0-beta.20";
 var dependencies = {
   "@clack/prompts": "^0.7.0",
   "@depot/cli": "0.0.1-cli.2.55.0",
@@ -816,7 +815,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-base": "^1.22.0",
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
-  "@trigger.dev/core": "workspace:^3.0.0-beta.1",
+  "@trigger.dev/core": "workspace:3.0.0-beta.20",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -833,12 +832,10 @@ var dependencies = {
   "import-meta-resolve": "^4.0.0",
   ink: "^4.4.1",
   "jsonc-parser": "^3.2.1",
-  jsonlines: "^0.1.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-debounce": "^4.0.0",
   "p-throttle": "^6.1.0",
@@ -850,7 +847,6 @@ var dependencies = {
   "simple-git": "^3.19.0",
   "socket.io-client": "^4.7.4",
   "source-map-support": "^0.5.21",
-  "supports-color": "^9.4.0",
   "terminal-link": "^3.0.0",
   "tiny-invariant": "^1.2.0",
   "tsconfig-paths": "^4.2.0",
@@ -894,13 +890,12 @@ var package_default = {
   type: "module",
   exports: "./dist/index.js",
   bin: {
-    "trigger.dev": "./dist/index.js"
+    triggerdev: "./dist/index.js"
   },
   devDependencies: {
     "@trigger.dev/core-apps": "workspace:*",
     "@trigger.dev/tsconfig": "workspace:*",
     "@types/gradient-string": "^1.1.2",
-    "@types/jsonlines": "^0.1.5",
     "@types/mock-fs": "^4.13.1",
     "@types/node": "18",
     "@types/object-hash": "^3.0.6",
@@ -908,8 +903,8 @@ var package_default = {
     "@types/semver": "^7.3.13",
     "@types/ws": "^8.5.3",
     "cpy-cli": "^5.0.0",
+    nodemon: "^3.0.1",
     "npm-run-all": "^4.1.5",
-    "npm-watch": "^0.11.0",
     open: "^10.0.3",
     "p-retry": "^6.1.0",
     rimraf: "^3.0.2",
@@ -919,9 +914,6 @@ var package_default = {
     vitest: "^0.34.4",
     "xdg-app-paths": "^8.3.0"
   },
-  watch: {
-    "build:prod-containerfile": "src/Containerfile.prod"
-  },
   scripts: {
     typecheck: "tsc -p tsconfig.check.json",
     build: "npm run clean && run-p build:**",
@@ -931,7 +923,7 @@ var package_default = {
     dev: "npm run clean && run-p dev:**",
     "dev:main": "tsup --watch",
     "dev:workers": "tsup --config tsup.workers.config.ts --watch",
-    "dev:prod-containerfile": "npm-watch",
+    "dev:test": "nodemon -w src/Containerfile.prod -x npm run build:prod-containerfile",
     clean: "rimraf dist",
     start: "node dist/index.js",
     test: "vitest"
@@ -1147,7 +1139,8 @@ async function zodfetch(schema, url, requestInit) {
 }
 
 // src/cli/common.ts
-import { flattenAttributes, recordSpanException } from "@trigger.dev/core/v3";
+import { flattenAttributes } from "@trigger.dev/core/v3";
+import { recordSpanException } from "@trigger.dev/core/v3/workers";
 import { z } from "zod";
 
 // src/telemetry/tracing.ts
@@ -1157,6 +1150,10 @@ import { Resource, detectResourcesSync, processDetectorSync } from "@opentelemet
 import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
 import { DiagConsoleLogger, DiagLogLevel, diag, trace } from "@opentelemetry/api";
+import {
+  SEMRESATTRS_SERVICE_NAME,
+  SEMRESATTRS_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
 function initializeTracing() {
   if (process.argv.includes("--skip-telemetry") || process.env.TRIGGER_DEV_SKIP_TELEMETRY) {
     return;
@@ -1168,7 +1165,8 @@ function initializeTracing() {
     detectors: [processDetectorSync]
   }).merge(
     new Resource({
-      service: "trigger.dev cli v3"
+      [SEMRESATTRS_SERVICE_NAME]: "trigger.dev cli v3",
+      [SEMRESATTRS_SERVICE_VERSION]: version
     })
   );
   const traceProvider = new NodeTracerProvider({
@@ -1185,10 +1183,9 @@ function initializeTracing() {
   });
   const spanExporter = new OTLPTraceExporter({
     url: "https://otel.baselime.io/v1",
-    timeoutMillis: 500,
+    timeoutMillis: 5e3,
     headers: {
-      "x-api-key": "e9f963244f8b092850d42e34a5339b2d5e68070b".split("").reverse().join("")
-      // this is a joke
+      "x-api-key": "b6e0fbbaf8dc2524773d2152ae2e9eb5c7fbaa52"
     }
   });
   const spanProcessor = new SimpleSpanProcessor(spanExporter);
@@ -1201,7 +1198,7 @@ function initializeTracing() {
 }
 var provider = initializeTracing();
 function getTracer() {
-  return trace.getTracer("trigger.dev cli", version);
+  return trace.getTracer("trigger.dev cli v3", version);
 }
 
 // src/cli/common.ts
@@ -1307,7 +1304,7 @@ var Logger = class {
     const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
     if (kind) {
       const [firstLine, ...otherLines] = message.split("\n");
-      const notes = otherLines.length > 0 ? otherLines.map((text2) => ({ text: text2 })) : void 0;
+      const notes = otherLines.length > 0 ? otherLines.map((text3) => ({ text: text3 })) : void 0;
       return formatMessagesSync([{ text: firstLine, notes }], {
         color: true,
         kind,
@@ -1322,6 +1319,83 @@ var logger = new Logger();
 
 // src/cli/common.ts
 import { outro } from "@clack/prompts";
+
+// src/utilities/cliOutput.ts
+import { log } from "@clack/prompts";
+import chalk2 from "chalk";
+var green = "#4FFF54";
+var purple = "#735BF3";
+function chalkGreen(text3) {
+  return chalk2.hex(green)(text3);
+}
+function chalkPurple(text3) {
+  return chalk2.hex(purple)(text3);
+}
+function chalkGrey(text3) {
+  return chalk2.hex("#878C99")(text3);
+}
+function chalkError(text3) {
+  return chalk2.hex("#E11D48")(text3);
+}
+function chalkWarning(text3) {
+  return chalk2.yellow(text3);
+}
+function chalkSuccess(text3) {
+  return chalk2.hex("#28BF5C")(text3);
+}
+function chalkLink(text3) {
+  return chalk2.underline.hex("#D7D9DD")(text3);
+}
+function chalkWorker(text3) {
+  return chalk2.hex("#FFFF89")(text3);
+}
+function chalkTask(text3) {
+  return chalk2.hex("#60A5FA")(text3);
+}
+function chalkRun(text3) {
+  return chalk2.hex("#A78BFA")(text3);
+}
+function logo() {
+  return `${chalk2.hex(green).bold("Trigger")}${chalk2.hex(purple).bold(".dev")}`;
+}
+function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
+  let formattedDate = new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).format(date);
+  formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
+  return formattedDate;
+}
+function prettyError(header, body, footer) {
+  const prefix = "Error: ";
+  const indent = Array(prefix.length).fill(" ").join("");
+  const spacing = "\n\n";
+  const prettyPrefix = chalkError(prefix);
+  const withIndents = (text3) => text3?.split("\n").map((line) => `${indent}${line}`).join("\n");
+  const prettyBody = withIndents(body);
+  const prettyFooter = withIndents(footer);
+  log.error(
+    `${prettyPrefix}${header}${prettyBody ? `${spacing}${prettyBody}` : ""}${prettyFooter ? `${spacing}${prettyFooter}` : ""}`
+  );
+}
+function prettyWarning(header, body, footer) {
+  const prefix = "Warning: ";
+  const indent = Array(prefix.length).fill(" ").join("");
+  const spacing = "\n\n";
+  const prettyPrefix = chalkWarning(prefix);
+  const withIndents = (text3) => text3?.split("\n").map((line) => `${indent}${line}`).join("\n");
+  const prettyBody = withIndents(body);
+  const prettyFooter = withIndents(footer);
+  log.warn(
+    `${prettyPrefix}${header}${prettyBody ? `${spacing}${prettyBody}` : ""}${prettyFooter ? `${spacing}${prettyFooter}` : ""}`
+  );
+}
+
+// src/cli/common.ts
 var CommonCommandOptions = z.object({
   apiUrl: z.string().optional(),
   logLevel: z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log"),
@@ -1331,7 +1405,7 @@ var CommonCommandOptions = z.object({
 function commonOptions(command) {
   return command.option("--profile <profile>", "The login profile to use", "default").option("-a, --api-url <value>", "Override the API URL", "https://api.trigger.dev").option(
     "-l, --log-level <level>",
-    "The log level to use (debug, info, log, warn, error, none)",
+    "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
     "log"
   ).option("--skip-telemetry", "Opt-out of sending telemetry");
 }
@@ -1377,7 +1451,7 @@ async function wrapCommandAction(name, schema, options, action) {
       } else if (e instanceof SkipCommandError) {
       } else {
         recordSpanException(span, e);
-        logger.error(e instanceof Error ? e.message : String(e));
+        logger.log(`${chalkError("X Error:")} ${e instanceof Error ? e.message : String(e)}`);
       }
       span.end();
       throw e;
@@ -1420,31 +1494,34 @@ import fsModule, { writeFile } from "fs/promises";
 import fs from "node:fs";
 import { tmpdir } from "node:os";
 import pathModule from "node:path";
-async function createFile(path6, contents) {
-  await fsModule.mkdir(pathModule.dirname(path6), { recursive: true });
-  await fsModule.writeFile(path6, contents);
-  return path6;
+async function createFile(path7, contents) {
+  await fsModule.mkdir(pathModule.dirname(path7), { recursive: true });
+  await fsModule.writeFile(path7, contents);
+  return path7;
+}
+async function pathExists(path7) {
+  return fsSync.existsSync(path7);
 }
-async function pathExists(path6) {
-  return fsSync.existsSync(path6);
+async function removeFile(path7) {
+  await fsModule.unlink(path7);
 }
-async function readFile(path6) {
-  return await fsModule.readFile(path6, "utf8");
+async function readFile(path7) {
+  return await fsModule.readFile(path7, "utf8");
 }
-async function readJSONFile(path6) {
-  const fileContents = await fsModule.readFile(path6, "utf8");
+async function readJSONFile(path7) {
+  const fileContents = await fsModule.readFile(path7, "utf8");
   return JSON.parse(fileContents);
 }
-async function writeJSONFile(path6, json) {
-  await writeFile(path6, JSON.stringify(json), "utf8");
+async function writeJSONFile(path7, json, pretty = false) {
+  await writeFile(path7, JSON.stringify(json, void 0, pretty ? 2 : void 0), "utf8");
 }
-function readJSONFileSync(path6) {
-  const fileContents = fsSync.readFileSync(path6, "utf8");
+function readJSONFileSync(path7) {
+  const fileContents = fsSync.readFileSync(path7, "utf8");
   return JSON.parse(fileContents);
 }
-function safeDeleteFileSync(path6) {
+function safeDeleteFileSync(path7) {
   try {
-    fs.unlinkSync(path6);
+    fs.unlinkSync(path7);
   } catch (error) {
   }
 }
@@ -1467,16 +1544,26 @@ function createTaskFileImports(taskFiles) {
 async function gatherTaskFiles(config) {
   const taskFiles = [];
   for (const triggerDir of config.triggerDirectories) {
-    const files = await fs2.promises.readdir(triggerDir, { withFileTypes: true });
-    for (const file of files) {
-      if (!file.isFile())
-        continue;
-      if (!file.name.endsWith(".js") && !file.name.endsWith(".ts"))
+    const files = await gatherTaskFilesFromDir(triggerDir, triggerDir, config);
+    taskFiles.push(...files);
+  }
+  return taskFiles;
+}
+async function gatherTaskFilesFromDir(dirPath, triggerDir, config) {
+  const taskFiles = [];
+  const files = await fs2.promises.readdir(dirPath, { withFileTypes: true });
+  for (const file of files) {
+    if (!file.isFile()) {
+      const fullPath = join(dirPath, file.name);
+      taskFiles.push(...await gatherTaskFilesFromDir(fullPath, triggerDir, config));
+    } else {
+      if (!file.name.endsWith(".js") && !file.name.endsWith(".ts") && !file.name.endsWith(".jsx") && !file.name.endsWith(".tsx")) {
         continue;
-      const fullPath = join(triggerDir, file.name);
+      }
+      const fullPath = join(dirPath, file.name);
       const filePath = relative(config.projectDir, fullPath);
-      const importPath = filePath.replace(/\.(js|ts)$/, "");
-      const importName = importPath.replace(/\//g, "_").replace(/\./g, "_").replace(/-/g, "_");
+      const importName = filePath.replace(/\..+$/, "").replace(/[^a-zA-Z0-9_$]/g, "_");
+      const importPath = filePath.replace(/\\/g, "/");
       taskFiles.push({ triggerDir, importPath, importName, filePath });
     }
   }
@@ -1493,9 +1580,12 @@ async function getTriggerDirectories(dirPath) {
   const entries = await fs2.promises.readdir(dirPath, { withFileTypes: true });
   const triggerDirectories = [];
   for (const entry of entries) {
-    if (!entry.isDirectory() || IGNORED_DIRS.includes(entry.name))
+    if (!entry.isDirectory() || IGNORED_DIRS.includes(entry.name) || entry.name.startsWith("."))
       continue;
     const fullPath = join(dirPath, entry.name);
+    if (fullPath.endsWith("app/api/trigger")) {
+      continue;
+    }
     if (entry.name === "trigger") {
       triggerDirectories.push(fullPath);
     }
@@ -1535,6 +1625,11 @@ function readAuthConfigProfile(profile = "default") {
     return void 0;
   }
 }
+function deleteAuthConfigProfile(profile = "default") {
+  const existingConfig = readAuthConfigFile() || {};
+  delete existingConfig[profile];
+  writeAuthConfigFile(existingConfig);
+}
 function readAuthConfigFile() {
   try {
     const authConfigFilePath = getAuthConfigFilePath();
@@ -1564,6 +1659,15 @@ async function getConfigPath(dir, fileName) {
   });
   return await findUp(fileName ? [fileName] : CONFIG_FILES, { cwd: dir });
 }
+async function findFilePath(dir, fileName) {
+  const result = await findUp([fileName], { cwd: dir });
+  logger.debug("Searched for the file", {
+    dir,
+    fileName,
+    result
+  });
+  return result;
+}
 async function readConfig(dir, options) {
   const absoluteDir = path2.resolve(process.cwd(), dir);
   const configPath = await getConfigPath(dir, options?.configFile);
@@ -1601,7 +1705,8 @@ async function readConfig(dir, options) {
   });
   const userConfigModule = await import(builtConfigFileHref);
   const rawConfig = await normalizeConfig(
-    userConfigModule ? userConfigModule.config : { project: options?.projectRef }
+    userConfigModule?.config,
+    options?.projectRef ? { project: options?.projectRef } : void 0
   );
   const config = Config.parse(rawConfig);
   return {
@@ -1610,82 +1715,36 @@ async function readConfig(dir, options) {
     path: configPath
   };
 }
-async function resolveConfig(path6, config) {
+async function resolveConfig(path7, config) {
   if (!config.triggerDirectories) {
-    config.triggerDirectories = await findTriggerDirectories(path6);
+    config.triggerDirectories = await findTriggerDirectories(path7);
   }
   config.triggerDirectories = resolveTriggerDirectories(config.triggerDirectories);
+  logger.debug("Resolved trigger directories", { triggerDirectories: config.triggerDirectories });
   if (!config.triggerUrl) {
     config.triggerUrl = CLOUD_API_URL;
   }
   if (!config.projectDir) {
-    config.projectDir = path6;
+    config.projectDir = path7;
   }
   if (!config.tsconfigPath) {
-    config.tsconfigPath = await getConfigPath(path6, "tsconfig.json");
+    config.tsconfigPath = await findFilePath(path7, "tsconfig.json");
   }
   return config;
 }
-async function normalizeConfig(config) {
+async function normalizeConfig(config, overrides) {
+  let normalized = config;
   if (typeof config === "function") {
-    config = config();
+    normalized = await config();
   }
-  return await config;
+  normalized = { ...normalized, ...overrides };
+  return normalized;
 }
 
 // src/utilities/initialBanner.ts
-import { spinner } from "@clack/prompts";
 import chalk3 from "chalk";
-import supportsColor from "supports-color";
 import checkForUpdate from "update-check";
 
-// src/utilities/cliOutput.ts
-import chalk2 from "chalk";
-var green = "#4FFF54";
-var purple = "#735BF3";
-function chalkPurple(text2) {
-  return chalk2.hex(purple)(text2);
-}
-function chalkGrey(text2) {
-  return chalk2.hex("#878C99")(text2);
-}
-function chalkError(text2) {
-  return chalk2.hex("#E11D48")(text2);
-}
-function chalkWarning(text2) {
-  return chalk2.yellow(text2);
-}
-function chalkSuccess(text2) {
-  return chalk2.hex("#28BF5C")(text2);
-}
-function chalkLink(text2) {
-  return chalk2.underline.hex("#D7D9DD")(text2);
-}
-function chalkWorker(text2) {
-  return chalk2.hex("#FFFF89")(text2);
-}
-function chalkTask(text2) {
-  return chalk2.hex("#60A5FA")(text2);
-}
-function chalkRun(text2) {
-  return chalk2.hex("#A78BFA")(text2);
-}
-function logo() {
-  return `${chalk2.hex(green).bold("Trigger")}${chalk2.hex(purple).bold(".dev")}`;
-}
-function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
-  let formattedDate = new Intl.DateTimeFormat("en-US", {
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false
-  }).format(date);
-  formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
-  return formattedDate;
-}
-
 // src/utilities/getVersion.ts
 import path3 from "path";
 function getVersion() {
@@ -1694,13 +1753,32 @@ function getVersion() {
   return packageJsonContent.version ?? "1.0.0";
 }
 
+// src/utilities/windows.ts
+import { log as log2, spinner as clackSpinner } from "@clack/prompts";
+var isWindows = process.platform === "win32";
+function escapeImportPath(path7) {
+  return isWindows ? path7.replaceAll("\\", "\\\\") : path7;
+}
+var ballmerSpinner = () => ({
+  start: (msg) => {
+    log2.step(msg ?? "");
+  },
+  stop: (msg, code) => {
+    log2.message(msg ?? "");
+  },
+  message: (msg) => {
+    log2.message(msg ?? "");
+  }
+});
+var spinner = () => isWindows ? ballmerSpinner() : clackSpinner();
+
 // src/utilities/initialBanner.ts
 async function printInitialBanner(performUpdateCheck = true) {
-  const packageVersion = getVersion();
-  const text2 = `
-${logo()} ${chalkGrey(`(${packageVersion})`)}
+  const cliVersion = getVersion();
+  const text3 = `
+${logo()} ${chalkGrey(`(${cliVersion})`)}
 `;
-  logger.info(text2);
+  logger.info(text3);
   let maybeNewVersion;
   if (performUpdateCheck) {
     const loadingSpinner = spinner();
@@ -1708,7 +1786,7 @@ ${logo()} ${chalkGrey(`(${packageVersion})`)}
     maybeNewVersion = await updateCheck();
     if (maybeNewVersion !== void 0) {
       loadingSpinner.stop(`Update available ${chalk3.green(maybeNewVersion)}`);
-      const currentMajor = parseInt(packageVersion.split(".")[0]);
+      const currentMajor = parseInt(cliVersion.split(".")[0]);
       const newMajor = parseInt(maybeNewVersion.split(".")[0]);
       if (newMajor > currentMajor) {
         logger.warn(
@@ -1723,18 +1801,26 @@ After installation, run Trigger.dev with \`npx trigger.dev\`.`
   }
 }
 async function printStandloneInitialBanner(performUpdateCheck = true) {
-  const packageVersion = getVersion();
-  let text2 = `
-${logo()} ${chalkGrey("(v3 Developer Preview)")}`;
+  const cliVersion = getVersion();
   if (performUpdateCheck) {
     const maybeNewVersion = await updateCheck();
     if (maybeNewVersion !== void 0) {
-      text2 = `${text2} (update available ${chalk3.green(maybeNewVersion)})`;
+      logger.log(`
+${logo()} ${chalkGrey(`(${cliVersion} -> ${chalk3.green(maybeNewVersion)})`)}`);
+    } else {
+      logger.log(`
+${logo()} ${chalkGrey(`(${cliVersion})`)}`);
     }
+  } else {
+    logger.log(`
+${logo()} ${chalkGrey(`(${cliVersion})`)}`);
   }
-  logger.log(text2 + "\n" + (supportsColor.stdout ? chalkGrey("-".repeat(54)) : "-".repeat(54)));
+  logger.log(`${chalkGrey("-".repeat(54))}`);
 }
-function printDevBanner() {
+function printDevBanner(printTopBorder = true) {
+  if (printTopBorder) {
+    logger.log(chalkGrey("-".repeat(54)));
+  }
   logger.log(
     `${chalkGrey("Key:")} ${chalkWorker("Version")} ${chalkGrey("|")} ${chalkTask(
       "Task"
@@ -1746,7 +1832,7 @@ async function doUpdateCheck() {
   let update = null;
   try {
     update = await checkForUpdate(package_default, {
-      distTag: package_default.version.startsWith("0.0.0") ? "beta" : "latest"
+      distTag: package_default.version.startsWith("3.0.0-beta") ? "beta" : "latest"
     });
   } catch (err) {
   }
@@ -1764,26 +1850,20 @@ async function installPackages(packages, options) {
   const cwd = options?.cwd ?? process.cwd();
   logger.debug("Installing packages", { packages });
   await setPackageJsonDeps(join3(cwd, "package.json"), packages);
-  const childProcess2 = execa(
+  await execa(
     "npm",
     ["install", "--install-strategy", "nested", "--ignore-scripts", "--no-audit", "--no-fund"],
     {
       cwd,
-      stderr: "inherit"
+      stderr: "pipe"
     }
   );
-  await new Promise((res, rej) => {
-    childProcess2.on("error", (e) => rej(e));
-    childProcess2.on("close", () => res());
-  });
-  await childProcess2;
-  return;
 }
-function detectPackageNameFromImportPath(path6) {
-  if (path6.startsWith("@")) {
-    return path6.split("/").slice(0, 2).join("/");
+function detectPackageNameFromImportPath(path7) {
+  if (path7.startsWith("@")) {
+    return path7.split("/").slice(0, 2).join("/");
   } else {
-    return path6.split("/")[0];
+    return path7.split("/")[0];
   }
 }
 function stripWorkspaceFromVersion(version2) {
@@ -1799,16 +1879,16 @@ function parsePackageName(packageSpecifier) {
   }
   return { name: packageSpecifier };
 }
-async function setPackageJsonDeps(path6, deps) {
+async function setPackageJsonDeps(path7, deps) {
   try {
-    const existingPackageJson = await readJSONFile(path6);
+    const existingPackageJson = await readJSONFile(path7);
     const newPackageJson = {
       ...existingPackageJson,
       dependencies: {
         ...deps
       }
     };
-    await writeJSONFile(path6, newPackageJson);
+    await writeJSONFile(path7, newPackageJson);
   } catch (error) {
     const defaultPackageJson = {
       name: "temp",
@@ -1816,13 +1896,13 @@ async function setPackageJsonDeps(path6, deps) {
       description: "",
       dependencies: deps
     };
-    await writeJSONFile(path6, defaultPackageJson);
+    await writeJSONFile(path7, defaultPackageJson);
   }
 }
 
 // src/commands/login.ts
-import { intro as intro2, log, outro as outro2, select, spinner as spinner3 } from "@clack/prompts";
-import { recordSpanException as recordSpanException3 } from "@trigger.dev/core/v3";
+import { intro as intro2, log as log3, outro as outro3, select } from "@clack/prompts";
+import { recordSpanException as recordSpanException3 } from "@trigger.dev/core/v3/workers";
 
 // ../../node_modules/.pnpm/open@10.0.3/node_modules/open/index.js
 import process6 from "node:process";
@@ -2192,14 +2272,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve4(subprocess);
+        resolve5(subprocess);
       });
     });
   }
@@ -2316,7 +2396,7 @@ var decorateErrorWithCounts = (error, attemptNumber, options) => {
   return error;
 };
 async function pRetry(input, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     options = {
       onFailedAttempt() {
       },
@@ -2339,7 +2419,7 @@ async function pRetry(input, options) {
       try {
         const result = await input(attemptNumber);
         cleanUp();
-        resolve4(result);
+        resolve5(result);
       } catch (error) {
         try {
           if (!(error instanceof Error)) {
@@ -2369,10 +2449,10 @@ async function pRetry(input, options) {
 import { z as z3 } from "zod";
 
 // src/commands/whoami.ts
-import { intro, note, spinner as spinner2 } from "@clack/prompts";
+import { intro, note, outro as outro2 } from "@clack/prompts";
 
 // src/utilities/session.ts
-import { recordSpanException as recordSpanException2 } from "@trigger.dev/core/v3";
+import { recordSpanException as recordSpanException2 } from "@trigger.dev/core/v3/workers";
 var tracer2 = getTracer();
 async function isLoggedIn(profile = "default") {
   return await tracer2.startActiveSpan("isLoggedIn", async (span) => {
@@ -2447,16 +2527,23 @@ async function whoAmI(options, embedded = false) {
   if (!embedded) {
     intro(`Displaying your account details [${options?.profile ?? "default"}]`);
   }
-  const loadingSpinner = spinner2();
+  const loadingSpinner = spinner();
   loadingSpinner.start("Checking your account details");
   const authentication = await isLoggedIn(options?.profile);
   if (!authentication.ok) {
     if (authentication.error === "fetch failed") {
       loadingSpinner.stop("Fetch failed. Platform down?");
     } else {
-      loadingSpinner.stop(
-        `You must login first. Use \`trigger.dev login --profile ${options?.profile ?? "default"}\` to login.`
-      );
+      if (embedded) {
+        loadingSpinner.stop(
+          `Failed to check account details. You may want to run \`trigger.dev logout --profile ${options?.profile ?? "default"}\` and try again.`
+        );
+      } else {
+        loadingSpinner.stop(
+          `You must login first. Use \`trigger.dev login --profile ${options?.profile ?? "default"}\` to login.`
+        );
+        outro2("Whoami failed");
+      }
     }
     return {
       success: false,
@@ -2521,6 +2608,29 @@ async function login(options) {
       if (!opts.embedded) {
         intro2("Logging in to Trigger.dev");
       }
+      const accessTokenFromEnv = process.env.TRIGGER_ACCESS_TOKEN;
+      if (accessTokenFromEnv) {
+        const auth = {
+          accessToken: accessTokenFromEnv,
+          apiUrl: process.env.TRIGGER_API_URL ?? "https://api.trigger.dev"
+        };
+        const apiClient3 = new CliApiClient(auth.apiUrl, auth.accessToken);
+        const userData = await apiClient3.whoAmI();
+        if (!userData.success) {
+          throw new Error(userData.error);
+        }
+        return {
+          ok: true,
+          profile: options?.profile ?? "default",
+          userId: userData.data.userId,
+          email: userData.data.email,
+          dashboardUrl: userData.data.dashboardUrl,
+          auth: {
+            accessToken: auth.accessToken,
+            apiUrl: auth.apiUrl
+          }
+        };
+      }
       const authConfig = readAuthConfigProfile(options?.profile);
       if (authConfig && authConfig.accessToken) {
         const whoAmIResult = await whoAmI(
@@ -2529,10 +2639,18 @@ async function login(options) {
             skipTelemetry: !span.isRecording(),
             logLevel: logger.loggerLevel
           },
-          opts.embedded
+          true
         );
         if (!whoAmIResult.success) {
-          throw new Error(whoAmIResult.error);
+          prettyError("Unable to validate existing personal access token", whoAmIResult.error);
+          if (!opts.embedded) {
+            outro3(
+              `Login failed using stored token. To fix, first logout using \`trigger.dev logout${options?.profile ? ` --profile ${options.profile}` : ""}\` and then try again.`
+            );
+            throw new SkipLoggingError(whoAmIResult.error);
+          } else {
+            throw new Error(whoAmIResult.error);
+          }
         } else {
           if (!opts.embedded) {
             const continueOption = await select({
@@ -2550,7 +2668,7 @@ async function login(options) {
               initialValue: false
             });
             if (continueOption !== true) {
-              outro2("Already logged in");
+              outro3("Already logged in");
               span.setAttributes({
                 "cli.userId": whoAmIResult.data.userId,
                 "cli.email": whoAmIResult.data.email,
@@ -2591,16 +2709,16 @@ async function login(options) {
         }
       }
       if (opts.embedded) {
-        log.step("You must login to continue.");
+        log3.step("You must login to continue.");
       }
       const apiClient2 = new CliApiClient(authConfig?.apiUrl ?? opts.defaultApiUrl);
       const authorizationCodeResult = await createAuthorizationCode(apiClient2);
-      log.step(
+      log3.step(
         `Please visit the following URL to login:
 ${chalkLink(authorizationCodeResult.url)}`
       );
       await open_default(authorizationCodeResult.url);
-      const getPersonalAccessTokenSpinner = spinner3();
+      const getPersonalAccessTokenSpinner = spinner();
       getPersonalAccessTokenSpinner.start("Waiting for you to login");
       try {
         const indexResult = await pRetry(
@@ -2629,9 +2747,9 @@ ${chalkLink(authorizationCodeResult.url)}`
           throw new Error(whoAmIResult.error);
         }
         if (opts.embedded) {
-          log.step("Logged in successfully");
+          log3.step("Logged in successfully");
         } else {
-          outro2("Logged in successfully");
+          outro3("Logged in successfully");
         }
         span.end();
         return {
@@ -2648,7 +2766,7 @@ ${chalkLink(authorizationCodeResult.url)}`
       } catch (e) {
         getPersonalAccessTokenSpinner.stop(`Failed to get access token`);
         if (e instanceof AbortError) {
-          log.error(e.message);
+          log3.error(e.message);
         }
         recordSpanException3(span, e);
         span.end();
@@ -2697,7 +2815,7 @@ async function getPersonalAccessToken(apiClient2, authorizationCode) {
 async function createAuthorizationCode(apiClient2) {
   return await tracer.startActiveSpan("createAuthorizationCode", async (span) => {
     try {
-      const createAuthCodeSpinner = spinner3();
+      const createAuthCodeSpinner = spinner();
       createAuthCodeSpinner.start("Creating authorition code");
       const authorizationCodeResult = await apiClient2.createAuthorizationCode();
       if (!authorizationCodeResult.success) {
@@ -2721,10 +2839,42 @@ ${authorizationCodeResult.error}`
   });
 }
 
+// src/commands/deploy.ts
+import { Glob } from "glob";
+
 // src/utilities/build.ts
 import { readFileSync } from "node:fs";
 import { extname, isAbsolute } from "node:path";
 import tsConfigPaths from "tsconfig-paths";
+function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
+  return {
+    name: "trigger-bundle-core",
+    setup(build3) {
+      build3.onResolve({ filter: /.*/ }, (args) => {
+        if (!args.path.startsWith("@trigger.dev/core/v3")) {
+          return void 0;
+        }
+        const triggerSdkPath = __require.resolve("@trigger.dev/sdk/v3", { paths: [process.cwd()] });
+        logger.debug(`[${buildIdentifier}][trigger-bundle-core] Resolved @trigger.dev/sdk/v3`, {
+          ...args,
+          triggerSdkPath
+        });
+        const resolvedPath = __require.resolve(args.path, {
+          paths: [triggerSdkPath]
+        });
+        logger.debug(`[${buildIdentifier}][trigger-bundle-core] Externalizing ${args.path}`, {
+          ...args,
+          triggerSdkPath,
+          resolvedPath
+        });
+        return {
+          path: resolvedPath,
+          external: false
+        };
+      });
+    }
+  };
+}
 function workerSetupImportConfigPlugin(configPath) {
   return {
     name: "trigger-worker-setup",
@@ -2736,7 +2886,9 @@ function workerSetupImportConfigPlugin(configPath) {
         let workerSetupContents = readFileSync(args.path, "utf-8");
         workerSetupContents = workerSetupContents.replace(
           "__SETUP_IMPORTED_PROJECT_CONFIG__",
-          `import * as setupImportedConfigExports from "${configPath}"; const setupImportedConfig = setupImportedConfigExports.config;`
+          `import * as setupImportedConfigExports from "${escapeImportPath(
+            configPath
+          )}"; const setupImportedConfig = setupImportedConfigExports.config;`
         );
         logger.debug("Loading worker setup", {
           args,
@@ -2871,12 +3023,644 @@ function getLoaderForFile(file) {
   throw new Error(`Cannot get loader for file ${file}`);
 }
 
+// src/utilities/deployErrors.ts
+import chalk4 from "chalk";
+import { relative as relative2 } from "node:path";
+import { groupTaskMetadataIssuesByTask } from "@trigger.dev/core/v3";
+import terminalLink from "terminal-link";
+
+// src/utilities/links.ts
+var docs = {
+  config: {
+    home: "https://trigger.dev/docs/v3/trigger-config",
+    esm: "https://trigger.dev/docs/v3/trigger-config#esm-only-packages",
+    prisma: "https://trigger.dev/docs/v3/trigger-config#prisma-and-other-generators",
+    additionalPackages: "https://trigger.dev/docs/v3/trigger-config#prisma-and-other-generators"
+  }
+};
+var getInTouch = "https://trigger.dev/contact";
+
+// src/utilities/deployErrors.ts
+function errorIsErrorLike(error) {
+  return error instanceof Error || typeof error === "object" && error !== null && "message" in error;
+}
+function parseBuildErrorStack(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (errorIsErrorLike(error)) {
+    if (typeof error.stack === "string") {
+      const isErrRequireEsm = error.stack.includes("ERR_REQUIRE_ESM");
+      let moduleName = null;
+      if (isErrRequireEsm) {
+        const moduleRegex = /node_modules\/(@[^\/]+\/[^\/]+|[^\/]+)\/[^\/]+\s/;
+        const match = moduleRegex.exec(error.stack);
+        if (match) {
+          moduleName = match[1];
+          return {
+            type: "esm-require-error",
+            moduleName
+          };
+        }
+      }
+    } else {
+      return error.message;
+    }
+  }
+}
+function logESMRequireError(parsedError, resolvedConfig) {
+  logger.log(
+    `
+${chalkError("X Error:")} The ${chalkPurple(
+      parsedError.moduleName
+    )} module is being required even though it's ESM only, and builds only support CommonJS. There are two ${chalk4.underline(
+      "possible"
+    )} ways to fix this:`
+  );
+  logger.log(
+    `
+${chalkGrey("\u25CB")} Dynamically import the module in your code: ${chalkGrey(
+      `const myModule = await import("${parsedError.moduleName}");`
+    )}`
+  );
+  if (resolvedConfig.status === "file") {
+    const relativePath = relative2(resolvedConfig.config.projectDir, resolvedConfig.path).replace(
+      /\\/g,
+      "/"
+    );
+    logger.log(
+      `${chalkGrey("\u25CB")} ${chalk4.underline("Or")} add ${chalkPurple(
+        parsedError.moduleName
+      )} to the ${chalkGreen("dependenciesToBundle")} array in your config file ${chalkGrey(
+        `(${relativePath})`
+      )}. This will bundle the module with your code.
+`
+    );
+  } else {
+    logger.log(
+      `${chalkGrey("\u25CB")} ${chalk4.underline("Or")} add ${chalkPurple(
+        parsedError.moduleName
+      )} to the ${chalkGreen("dependenciesToBundle")} array in your config file ${chalkGrey(
+        "(you'll need to create one)"
+      )}. This will bundle the module with your code.
+`
+    );
+  }
+  logger.log(
+    `${chalkGrey("\u25CB")} For more info see the ${terminalLink("relevant docs", docs.config.esm)}.
+`
+  );
+}
+function parseNpmInstallError(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    if (typeof error.stack === "string") {
+      const isPackageNotFoundError = error.stack.includes("ERR! 404 Not Found") && error.stack.includes("is not in this registry");
+      let packageName = null;
+      if (isPackageNotFoundError) {
+        const packageNameRegex = /'([^']+)' is not in this registry/;
+        const match = packageNameRegex.exec(error.stack);
+        if (match) {
+          packageName = match[1];
+        }
+      }
+      if (packageName) {
+        return {
+          type: "package-not-found-error",
+          packageName
+        };
+      }
+      const noMatchingVersionRegex = /No matching version found for ([^\s]+)\s/;
+      const noMatchingVersionMatch = noMatchingVersionRegex.exec(error.stack);
+      if (noMatchingVersionMatch) {
+        return {
+          type: "no-matching-version-error",
+          packageName: noMatchingVersionMatch[1].replace(/.$/, "")
+        };
+      }
+      return error.message;
+    } else {
+      return error.message;
+    }
+  }
+  return "Unknown error";
+}
+function logTaskMetadataParseError(zodIssues, tasks) {
+  logger.log(
+    `
+${chalkError("X Error:")} Failed to start. The following ${zodIssues.length === 1 ? "task issue was" : "task issues were"} found:`
+  );
+  const groupedIssues = groupTaskMetadataIssuesByTask(tasks, zodIssues);
+  for (const key in groupedIssues) {
+    const taskWithIssues = groupedIssues[key];
+    if (!taskWithIssues) {
+      continue;
+    }
+    logger.log(
+      `
+  ${chalkWarning("\u276F")} ${taskWithIssues.exportName} ${chalkGrey("in")} ${taskWithIssues.filePath}`
+    );
+    for (const issue of taskWithIssues.issues) {
+      if (issue.path) {
+        logger.log(`    ${chalkError("x")} ${issue.path} ${chalkGrey(issue.message)}`);
+      } else {
+        logger.log(`    ${chalkError("x")} ${chalkGrey(issue.message)}`);
+      }
+    }
+  }
+}
+
+// src/utilities/safeJsonParse.ts
+function safeJsonParse(json) {
+  if (!json) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utilities/javascriptProject.ts
+import { $ } from "execa";
+import { join as join4 } from "node:path";
+
+// src/utilities/getUserPackageManager.ts
+import { findUp as findUp2 } from "find-up";
+import { basename } from "path";
+async function getUserPackageManager(path7) {
+  const packageManager = await detectPackageManager(path7);
+  logger.debug("Detected package manager", { packageManager });
+  return packageManager;
+}
+async function detectPackageManager(path7) {
+  try {
+    return await detectPackageManagerFromArtifacts(path7);
+  } 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(path7) {
+  const artifacts = {
+    yarn: "yarn.lock",
+    pnpm: "pnpm-lock.yaml",
+    npm: "package-lock.json",
+    npmShrinkwrap: "npm-shrinkwrap.json"
+  };
+  const foundPath = await findUp2(Object.values(artifacts), { cwd: path7 });
+  if (!foundPath) {
+    throw new Error("Could not detect package manager from artifacts");
+  }
+  logger.debug("Found path from package manager artifacts", { foundPath });
+  switch (basename(foundPath)) {
+    case artifacts.yarn:
+      return "yarn";
+    case artifacts.pnpm:
+      return "pnpm";
+    case artifacts.npm:
+    case artifacts.npmShrinkwrap:
+      return "npm";
+    default:
+      throw new Error(`Unhandled package manager detection path: ${foundPath}`);
+  }
+}
+
+// src/utilities/assertExhaustive.ts
+function assertExhaustive(x) {
+  throw new Error("Unexpected object: " + x);
+}
+
+// src/utilities/javascriptProject.ts
+var BuiltInModules = /* @__PURE__ */ new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib"
+]);
+var JavascriptProject = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  _packageJson;
+  _packageManager;
+  get packageJson() {
+    if (!this._packageJson) {
+      this._packageJson = readJSONFileSync(join4(this.projectPath, "package.json"));
+    }
+    return this._packageJson;
+  }
+  get scripts() {
+    return {
+      postinstall: this.packageJson.scripts?.postinstall ?? ""
+    };
+  }
+  async install() {
+    const command = await this.#getCommand();
+    try {
+      await command.installDependencies({
+        cwd: this.projectPath
+      });
+    } catch (error) {
+      logger.debug(`Failed to install dependencies using ${command.name}`, {
+        error
+      });
+    }
+  }
+  async resolve(packageName, options) {
+    if (BuiltInModules.has(packageName)) {
+      return void 0;
+    }
+    const opts = { allowDev: false, ...options };
+    const packageJsonVersion = this.packageJson.dependencies?.[packageName];
+    if (typeof packageJsonVersion === "string") {
+      return packageJsonVersion;
+    }
+    if (opts.allowDev) {
+      const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
+      if (typeof devPackageJsonVersion === "string") {
+        return devPackageJsonVersion;
+      }
+    }
+    const command = await this.#getCommand();
+    try {
+      const version2 = await command.resolveDependencyVersion(packageName, {
+        cwd: this.projectPath
+      });
+      if (version2) {
+        return version2;
+      }
+    } catch (error) {
+      logger.debug(`Failed to resolve dependency version using ${command.name}`, {
+        packageName,
+        error
+      });
+    }
+  }
+  async #getCommand() {
+    const packageManager = await this.getPackageManager();
+    switch (packageManager) {
+      case "npm":
+        return new NPMCommands();
+      case "pnpm":
+        return new PNPMCommands();
+      case "yarn":
+        return new YarnCommands();
+      default:
+        assertExhaustive(packageManager);
+    }
+  }
+  async getPackageManager() {
+    if (!this._packageManager) {
+      this._packageManager = await getUserPackageManager(this.projectPath);
+    }
+    return this._packageManager;
+  }
+};
+var PNPMCommands = class {
+  get name() {
+    return "pnpm";
+  }
+  get cmd() {
+    return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+  }
+  async installDependencies(options) {
+    const { stdout, stderr } = await $({ cwd: options.cwd })`${this.cmd} install`;
+    logger.debug(`Installing dependencies using ${this.name}`, { stdout, stderr });
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageName} -r --json`;
+    const result = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageName} version using ${this.name}`, { result });
+    for (const dep of result) {
+      const dependency = dep.dependencies?.[packageName];
+      if (dependency) {
+        return dependency.version;
+      }
+    }
+  }
+};
+var NPMCommands = class {
+  get name() {
+    return "npm";
+  }
+  get cmd() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+  }
+  async installDependencies(options) {
+    const { stdout, stderr } = await $({ cwd: options.cwd })`${this.cmd} install`;
+    logger.debug(`Installing dependencies using ${this.name}`, { stdout, stderr });
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageName} --json`;
+    const output = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageName} version using ${this.name}`, { output });
+    return this.#recursivelySearchDependencies(output.dependencies, packageName);
+  }
+  #recursivelySearchDependencies(dependencies2, packageName) {
+    for (const [name, dependency] of Object.entries(dependencies2)) {
+      if (name === packageName) {
+        return dependency.version;
+      }
+      if (dependency.dependencies) {
+        const result = this.#recursivelySearchDependencies(dependency.dependencies, packageName);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+};
+var YarnCommands = class {
+  get name() {
+    return "yarn";
+  }
+  get cmd() {
+    return process.platform === "win32" ? "yarn.cmd" : "yarn";
+  }
+  async installDependencies(options) {
+    const { stdout, stderr } = await $({ cwd: options.cwd })`${this.cmd} install`;
+    logger.debug(`Installing dependencies using ${this.name}`, { stdout, stderr });
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} info ${packageName} --json`;
+    const lines = stdout.split("\n");
+    logger.debug(`Resolving ${packageName} version using ${this.name}`, { lines });
+    for (const line of lines) {
+      const json = JSON.parse(line);
+      if (json.value === packageName) {
+        return json.children.Version;
+      }
+    }
+  }
+};
+
+// src/utilities/resolveInternalFilePath.ts
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function cliRootPath() {
+  const __filename2 = fileURLToPath3(import.meta.url);
+  const __dirname2 = path5.dirname(__filename2);
+  return __dirname2;
+}
+
+// src/commands/update.ts
+import { confirm, intro as intro3, isCancel, log as log4, outro as outro4 } from "@clack/prompts";
+import { join as join5, resolve as resolve2 } from "path";
+var UpdateCommandOptions = CommonCommandOptions.pick({
+  logLevel: true,
+  skipTelemetry: true
+});
+function configureUpdateCommand(program2) {
+  return program2.command("update").description("Updates all @trigger.dev/* packages to match the CLI version").argument("[path]", "The path to the directory that contains the package.json file", ".").option(
+    "-l, --log-level <level>",
+    "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
+    "log"
+  ).option("--skip-telemetry", "Opt-out of sending telemetry").action(async (path7, options) => {
+    wrapCommandAction("dev", UpdateCommandOptions, options, async (opts) => {
+      await printStandloneInitialBanner(true);
+      await updateCommand(path7, opts);
+    });
+  });
+}
+var triggerPackageFilter = /^@trigger\.dev/;
+async function updateCommand(dir, options) {
+  await updateTriggerPackages(dir, options);
+}
+async function updateTriggerPackages(dir, options, embedded, requireUpdate) {
+  let hasOutput = false;
+  if (!embedded) {
+    intro3("Updating packages");
+  }
+  const projectPath = resolve2(process.cwd(), dir);
+  const { packageJson, readonlyPackageJson, packageJsonPath } = await getPackageJson(projectPath);
+  if (!packageJson) {
+    log4.error("Failed to load package.json. Try to re-run with `-l debug` to see what's going on.");
+    return false;
+  }
+  const cliVersion = getVersion();
+  const newCliVersion = await updateCheck();
+  if (newCliVersion) {
+    prettyWarning(
+      "You're not running the latest CLI version, please consider updating ASAP",
+      `Current:     ${cliVersion}
+Latest:      ${newCliVersion}`,
+      "Run latest:  npx trigger.dev@beta"
+    );
+    hasOutput = true;
+  }
+  const triggerDependencies = getTriggerDependencies(packageJson);
+  function getVersionMismatches(deps, targetVersion) {
+    const mismatches = [];
+    for (const dep of deps) {
+      if (dep.version === targetVersion) {
+        continue;
+      }
+      mismatches.push(dep);
+    }
+    return mismatches;
+  }
+  const versionMismatches = getVersionMismatches(triggerDependencies, cliVersion);
+  if (versionMismatches.length === 0) {
+    if (!embedded) {
+      outro4(`Nothing to do${newCliVersion ? " ..but you should really update your CLI!" : ""}`);
+      return hasOutput;
+    }
+    return hasOutput;
+  }
+  prettyWarning(
+    "Mismatch between your CLI version and installed packages",
+    "We recommend pinned versions for guaranteed compatibility"
+  );
+  if (!process.stdout.isTTY) {
+    outro4("Deploy failed");
+    console.log(
+      `ERROR: Version mismatch detected while running in CI. This won't end well. Aborting.
+  
+  Please run the dev command locally and check that your CLI version matches the one printed below. Additionally, all \`@trigger.dev/*\` packages also need to match this version.
+  
+  If your local CLI version doesn't match the one below, you may want to pin the CLI version in this CI step. To do that, just replace \`trigger.dev@beta\` with \`trigger.dev@<FULL_VERSION>\`, for example: \`npx trigger.dev@3.0.0-beta.17 deploy\`
+  
+  CLI version: ${cliVersion}
+  
+  Current package versions that don't match the CLI:
+  ${versionMismatches.map((dep) => `- ${dep.name}@${dep.version}`).join("\n")}
+`
+    );
+    process.exit(1);
+  }
+  log4.message("");
+  const userWantsToUpdate = await updateConfirmation(versionMismatches, cliVersion);
+  if (isCancel(userWantsToUpdate)) {
+    throw new OutroCommandError();
+  }
+  if (!userWantsToUpdate) {
+    if (requireUpdate) {
+      outro4("You shall not pass!");
+      logger.log(
+        `${chalkError(
+          "X Error:"
+        )} Update required: Version mismatches are a common source of bugs and errors. Please update or use \`--skip-update-check\` at your own risk.
+`
+      );
+      process.exit(1);
+    }
+    if (!embedded) {
+      outro4("You've been warned!");
+    }
+    return hasOutput;
+  }
+  const installSpinner = spinner();
+  installSpinner.start("Writing new package.json file");
+  const packageJsonBackupPath = `${packageJsonPath}.bak`;
+  await writeJSONFile(packageJsonBackupPath, readonlyPackageJson, true);
+  const exitHandler = async (sig) => {
+    log4.warn(
+      `You may have to manually roll back any package.json changes. Backup written to ${packageJsonBackupPath}`
+    );
+  };
+  process.prependOnceListener("exit", exitHandler);
+  mutatePackageJsonWithUpdatedPackages(packageJson, versionMismatches, cliVersion);
+  await writeJSONFile(packageJsonPath, packageJson, true);
+  async function revertPackageJsonChanges() {
+    await writeJSONFile(packageJsonPath, readonlyPackageJson, true);
+    await removeFile(packageJsonBackupPath);
+  }
+  installSpinner.message("Installing new package versions");
+  const jsProject = new JavascriptProject(projectPath);
+  let packageManager;
+  try {
+    packageManager = await jsProject.getPackageManager();
+    installSpinner.message(`Installing new package versions with ${packageManager}`);
+    await jsProject.install();
+  } catch (error) {
+    installSpinner.stop(
+      `Failed to install new package versions${packageManager ? ` with ${packageManager}` : ""}`
+    );
+    process.removeListener("exit", exitHandler);
+    await revertPackageJsonChanges();
+    throw error;
+  }
+  installSpinner.stop("Installed new package versions");
+  process.removeListener("exit", exitHandler);
+  await removeFile(packageJsonBackupPath);
+  if (!embedded) {
+    outro4(
+      `Packages updated${newCliVersion ? " ..but you should really update your CLI too!" : ""}`
+    );
+  }
+  return hasOutput;
+}
+function getTriggerDependencies(packageJson) {
+  const deps = [];
+  for (const type of ["dependencies", "devDependencies"]) {
+    for (const [name, version2] of Object.entries(packageJson[type] ?? {})) {
+      if (!version2) {
+        continue;
+      }
+      if (version2.startsWith("workspace")) {
+        continue;
+      }
+      if (!triggerPackageFilter.test(name)) {
+        continue;
+      }
+      const ignoredPackages = ["@trigger.dev/companyicons"];
+      if (ignoredPackages.includes(name)) {
+        continue;
+      }
+      deps.push({ type, name, version: version2 });
+    }
+  }
+  return deps;
+}
+function mutatePackageJsonWithUpdatedPackages(packageJson, depsToUpdate, targetVersion) {
+  for (const { type, name, version: version2 } of depsToUpdate) {
+    if (!packageJson[type]) {
+      throw new Error(
+        `No ${type} entry found in package.json. Please try to upgrade manually instead.`
+      );
+    }
+    packageJson[type][name] = targetVersion;
+  }
+}
+function printUpdateTable(depsToUpdate, targetVersion) {
+  log4.message("Suggested updates");
+  const tableData = depsToUpdate.map((dep) => ({
+    package: dep.name,
+    old: dep.version,
+    new: targetVersion
+  }));
+  logger.table(tableData);
+}
+async function updateConfirmation(depsToUpdate, targetVersion) {
+  printUpdateTable(depsToUpdate, targetVersion);
+  let confirmMessage = "Would you like to apply those updates?";
+  return await confirm({
+    message: confirmMessage
+  });
+}
+async function getPackageJson(absoluteProjectPath) {
+  const packageJsonPath = join5(absoluteProjectPath, "package.json");
+  const readonlyPackageJson = Object.freeze(await readJSONFile(packageJsonPath));
+  const packageJson = structuredClone(readonlyPackageJson);
+  return { packageJson, readonlyPackageJson, packageJsonPath };
+}
+
 // src/commands/deploy.ts
-import { Glob } from "glob";
 var DeployCommandOptions = CommonCommandOptions.extend({
   skipTypecheck: z4.boolean().default(false),
   skipDeploy: z4.boolean().default(false),
-  ignoreEnvVarCheck: z4.boolean().default(false),
   env: z4.enum(["prod", "staging"]),
   loadImage: z4.boolean().default(false),
   buildPlatform: z4.enum(["linux/amd64", "linux/arm64"]).default("linux/amd64"),
@@ -2886,7 +3670,9 @@ var DeployCommandOptions = CommonCommandOptions.extend({
   config: z4.string().optional(),
   projectRef: z4.string().optional(),
   outputMetafile: z4.string().optional(),
-  apiUrl: z4.string().optional()
+  apiUrl: z4.string().optional(),
+  saveLogs: z4.boolean().default(false),
+  skipUpdateCheck: z4.boolean().default(false)
 });
 function configureDeployCommand(program2) {
   return commonOptions(
@@ -2894,12 +3680,9 @@ function configureDeployCommand(program2) {
       "-e, --env <env>",
       "Deploy to a specific environment (currently only prod and staging are supported)",
       "prod"
-    ).option("--skip-typecheck", "Whether to skip the pre-build typecheck").option(
-      "--ignore-env-var-check",
-      "Detected missing environment variables won't block deployment"
-    ).option("-c, --config <config file>", "The name of the config file, found at [path]").option(
+    ).option("--skip-typecheck", "Whether to skip the pre-build typecheck").option("--skip-update-check", "Skip checking for @trigger.dev package updates").option("-c, --config <config file>", "The name of the config file, found at [path]").option(
       "-p, --project-ref <project ref>",
-      "The project ref. Required if there is no config file."
+      "The project ref. Required if there is no config file. This will override the project specified in the config file."
     )
   ).addOption(
     new CommandOption(
@@ -2921,6 +3704,11 @@ function configureDeployCommand(program2) {
       "--tag <tag>",
       "(Coming soon) Specify the tag to use when pushing the image to the registry"
     ).hideHelp()
+  ).addOption(
+    new CommandOption(
+      "--ignore-env-var-check",
+      "(deprecated) Detected missing environment variables won't block deployment"
+    ).hideHelp()
   ).addOption(new CommandOption("-D, --skip-deploy", "Skip deploying the image").hideHelp()).addOption(
     new CommandOption("--load-image", "Load the built image into your local docker").hideHelp()
   ).addOption(
@@ -2933,10 +3721,15 @@ function configureDeployCommand(program2) {
       "--output-metafile <path>",
       "If provided, will save the esbuild metafile for the build to the specified path"
     ).hideHelp()
-  ).action(async (path6, options) => {
+  ).addOption(
+    new CommandOption(
+      "--save-logs",
+      "If provided, will save logs even for successful builds"
+    ).hideHelp()
+  ).action(async (path7, options) => {
     await handleTelemetry(async () => {
       await printStandloneInitialBanner(true);
-      await deployCommand(path6, options);
+      await deployCommand(path7, options);
     });
   });
 }
@@ -2947,7 +3740,10 @@ async function deployCommand(dir, options) {
 }
 async function _deployCommand(dir, options) {
   const span = trace2.getSpan(context.active());
-  intro3("Deploying project");
+  intro4("Deploying project");
+  if (!options.skipUpdateCheck) {
+    await updateTriggerPackages(dir, { ...options }, true, true);
+  }
   const authorization = await login({
     embedded: true,
     defaultApiUrl: options.apiUrl,
@@ -2990,7 +3786,7 @@ async function _deployCommand(dir, options) {
     throw new Error(deploymentEnv.error);
   }
   const environmentClient = new CliApiClient(authorization.auth.apiUrl, deploymentEnv.data.apiKey);
-  log2.step(
+  log5.step(
     `Preparing to deploy "${deploymentEnv.data.name}" (${resolvedConfig.config.project}) to ${options.env}`
   );
   const compilation = await compileProject(
@@ -2999,15 +3795,6 @@ async function _deployCommand(dir, options) {
     resolvedConfig.status === "file" ? resolvedConfig.path : void 0
   );
   logger.debug("Compilation result", { compilation });
-  if (compilation.envVars.length > 0) {
-    await checkEnvVars(
-      compilation.envVars ?? [],
-      resolvedConfig.config,
-      options,
-      environmentClient,
-      authorization.dashboardUrl
-    );
-  }
   const deploymentResponse = await environmentClient.initializeDeployment({
     contentHash: compilation.contentHash,
     userId: authorization.userId
@@ -3021,7 +3808,7 @@ async function _deployCommand(dir, options) {
     );
   }
   const version2 = deploymentResponse.data.version;
-  const deploymentSpinner = spinner4();
+  const deploymentSpinner = spinner();
   deploymentSpinner.start(`Deploying version ${version2}`);
   const selfHostedRegistryHost = deploymentResponse.data.registryHost ?? options.registry;
   const registryHost = selfHostedRegistryHost ?? "registry.trigger.dev";
@@ -3046,28 +3833,56 @@ async function _deployCommand(dir, options) {
         "Failed to initialize deployment. The deployment does not have any external build data. To deploy this project, you must use the --self-hosted flag to build and push the image yourself."
       );
     }
-    return buildAndPushImage({
-      registryHost,
-      auth: authorization.auth.accessToken,
-      imageTag: deploymentResponse.data.imageTag,
-      buildId: deploymentResponse.data.externalBuildData.buildId,
-      buildToken: deploymentResponse.data.externalBuildData.buildToken,
-      buildProjectId: deploymentResponse.data.externalBuildData.projectId,
-      cwd: compilation.path,
-      projectId: resolvedConfig.config.project,
-      deploymentId: deploymentResponse.data.id,
-      deploymentVersion: deploymentResponse.data.version,
-      contentHash: deploymentResponse.data.contentHash,
-      projectRef: resolvedConfig.config.project,
-      loadImage: options.loadImage,
-      buildPlatform: options.buildPlatform
-    });
+    return buildAndPushImage(
+      {
+        registryHost,
+        auth: authorization.auth.accessToken,
+        imageTag: deploymentResponse.data.imageTag,
+        buildId: deploymentResponse.data.externalBuildData.buildId,
+        buildToken: deploymentResponse.data.externalBuildData.buildToken,
+        buildProjectId: deploymentResponse.data.externalBuildData.projectId,
+        cwd: compilation.path,
+        projectId: resolvedConfig.config.project,
+        deploymentId: deploymentResponse.data.id,
+        deploymentVersion: deploymentResponse.data.version,
+        contentHash: deploymentResponse.data.contentHash,
+        projectRef: resolvedConfig.config.project,
+        loadImage: options.loadImage,
+        buildPlatform: options.buildPlatform
+      },
+      deploymentSpinner
+    );
   };
   const image = await buildImage();
+  const warnings = checkLogsForWarnings(image.logs);
+  if (!warnings.ok) {
+    await failDeploy(
+      deploymentResponse.data.shortCode,
+      warnings.summary,
+      image.logs,
+      deploymentSpinner,
+      warnings.warnings,
+      warnings.errors
+    );
+    throw new SkipLoggingError(`Failed to build project image: ${warnings.summary}`);
+  }
   if (!image.ok) {
-    deploymentSpinner.stop(`Failed to build project image: ${image.error}`);
+    await failDeploy(
+      deploymentResponse.data.shortCode,
+      image.error,
+      image.logs,
+      deploymentSpinner,
+      warnings.warnings
+    );
     throw new SkipLoggingError(`Failed to build project image: ${image.error}`);
   }
+  const preExitTasks = async () => {
+    printWarnings(warnings.warnings);
+    if (options.saveLogs) {
+      const logPath = await saveLogs(deploymentResponse.data.shortCode, image.logs);
+      log5.info(`Build logs have been saved to ${logPath}`);
+    }
+  };
   const imageReference = options.selfHosted ? `${selfHostedRegistryHost ? `${selfHostedRegistryHost}/` : ""}${image.image}${image.digest ? `@${image.digest}` : ""}` : `${registryHost}/${image.image}${image.digest ? `@${image.digest}` : ""}`;
   span?.setAttributes({
     "image.reference": imageReference
@@ -3076,6 +3891,7 @@ async function _deployCommand(dir, options) {
     deploymentSpinner.stop(
       `Project image built: ${imageReference}. Skipping deployment as requested`
     );
+    await preExitTasks();
     throw new SkipCommandError("Skipping deployment as requested");
   }
   deploymentSpinner.message(
@@ -3090,6 +3906,7 @@ async function _deployCommand(dir, options) {
   );
   if (!startIndexingResponse.success) {
     deploymentSpinner.stop(`Failed to start indexing: ${startIndexingResponse.error}`);
+    await preExitTasks();
     throw new SkipLoggingError(`Failed to start indexing: ${startIndexingResponse.error}`);
   }
   const finishedDeployment = await waitForDeploymentToFinish(
@@ -3098,26 +3915,33 @@ async function _deployCommand(dir, options) {
   );
   if (!finishedDeployment) {
     deploymentSpinner.stop(`Deployment failed to complete`);
+    await preExitTasks();
     throw new SkipLoggingError("Deployment failed to complete: unknown issue");
   }
   if (typeof finishedDeployment === "string") {
     deploymentSpinner.stop(`Deployment failed to complete: ${finishedDeployment}`);
+    await preExitTasks();
     throw new SkipLoggingError(`Deployment failed to complete: ${finishedDeployment}`);
   }
-  const deploymentLink = terminalLink(
+  const deploymentLink = terminalLink2(
     "View deployment",
     `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.config.project}/deployments/${finishedDeployment.shortCode}`
   );
   switch (finishedDeployment.status) {
     case "DEPLOYED": {
-      deploymentSpinner.stop("Deployment completed");
+      if (warnings.warnings.length > 0) {
+        deploymentSpinner.stop("Deployment completed with warnings");
+      } else {
+        deploymentSpinner.stop("Deployment completed");
+      }
+      await preExitTasks();
       const taskCount = finishedDeployment.worker?.tasks.length ?? 0;
       if (taskCount === 0) {
-        outro3(
+        outro5(
           `Version ${version2} deployed with no detected tasks. Please make sure you are exporting tasks in your project. ${deploymentLink}`
         );
       } else {
-        outro3(
+        outro5(
           `Version ${version2} deployed with ${taskCount} detected task${taskCount === 1 ? "" : "s"} ${deploymentLink}`
         );
       }
@@ -3125,10 +3949,29 @@ async function _deployCommand(dir, options) {
     }
     case "FAILED": {
       if (finishedDeployment.errorData) {
-        deploymentSpinner.stop(
-          `Deployment encountered an error: ${finishedDeployment.errorData.name}. ${deploymentLink}`
-        );
-        logger.error(finishedDeployment.errorData.stack);
+        if (finishedDeployment.errorData.name === "TaskMetadataParseError") {
+          const errorJson = safeJsonParse(finishedDeployment.errorData.stack);
+          if (errorJson) {
+            const parsedError2 = TaskMetadataFailedToParseData.safeParse(errorJson);
+            if (parsedError2.success) {
+              deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+              logTaskMetadataParseError(parsedError2.data.zodIssues, parsedError2.data.tasks);
+              await preExitTasks();
+              throw new SkipLoggingError(
+                `Deployment encountered an error: ${finishedDeployment.errorData.name}`
+              );
+            }
+          }
+        }
+        const parsedError = finishedDeployment.errorData.stack ? parseBuildErrorStack(finishedDeployment.errorData) ?? finishedDeployment.errorData.message : finishedDeployment.errorData.message;
+        if (typeof parsedError === "string") {
+          deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+          logger.log(`${chalkError("X Error:")} ${parsedError}`);
+        } else {
+          deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+          logESMRequireError(parsedError, resolvedConfig);
+        }
+        await preExitTasks();
         throw new SkipLoggingError(
           `Deployment encountered an error: ${finishedDeployment.errorData.name}`
         );
@@ -3136,62 +3979,132 @@ async function _deployCommand(dir, options) {
         deploymentSpinner.stop(
           `Deployment failed with an unknown error. Please contact eric@trigger.dev for help. ${deploymentLink}`
         );
+        await preExitTasks();
         throw new SkipLoggingError("Deployment failed with an unknown error");
       }
     }
     case "CANCELED": {
       deploymentSpinner.stop(`Deployment was canceled. ${deploymentLink}`);
+      await preExitTasks();
       throw new SkipLoggingError("Deployment was canceled");
     }
     case "TIMED_OUT": {
       deploymentSpinner.stop(`Deployment timed out. ${deploymentLink}`);
+      await preExitTasks();
       throw new SkipLoggingError("Deployment timed out");
     }
   }
 }
-async function checkEnvVars(envVars, config, options, environmentClient, apiUrl) {
-  return await tracer.startActiveSpan("detectEnvVars", async (span) => {
-    try {
-      span.setAttribute("envVars.check", envVars);
-      const environmentVariablesSpinner = spinner4();
-      environmentVariablesSpinner.start("Checking environment variables");
-      const environmentVariables = await environmentClient.getEnvironmentVariables(config.project);
-      if (!environmentVariables.success) {
-        environmentVariablesSpinner.stop(`Failed to fetch environment variables, skipping check`);
-      } else {
-        const missingEnvironmentVariables = envVars.filter(
-          (envVar) => environmentVariables.data.variables[envVar] === void 0
-        );
-        if (missingEnvironmentVariables.length > 0) {
-          environmentVariablesSpinner.stop(
-            `Found missing env vars in ${options.env}: ${arrayToSentence(
-              missingEnvironmentVariables
-            )}. ${options.ignoreEnvVarCheck ? "Continuing deployment because of --ignore-env-var-check. " : "Aborting deployment. "}${chalk4.bgBlueBright(
-              terminalLink(
-                "Manage env vars",
-                `${apiUrl}/projects/v3/${config.project}/environment-variables`
-              )
-            )}`
-          );
-          span.setAttributes({
-            "envVars.missing": missingEnvironmentVariables
-          });
-          if (!options.ignoreEnvVarCheck) {
-            throw new SkipLoggingError("Found missing environment variables");
-          } else {
-            span.end();
-            return;
-          }
-        }
-        environmentVariablesSpinner.stop(`Environment variable check passed`);
-      }
-      span.end();
-    } catch (e) {
-      recordSpanException4(span, e);
-      span.end();
-      throw e;
+function printErrors(errors) {
+  for (const error of errors ?? []) {
+    log5.error(`${chalkError("Error:")} ${error}`);
+  }
+}
+function printWarnings(warnings) {
+  for (const warning of warnings ?? []) {
+    log5.warn(`${chalkWarning("Warning:")} ${warning}`);
+  }
+}
+function checkLogsForWarnings(logs) {
+  const warnings = [
+    {
+      regex: /prisma:warn We could not find your Prisma schema/,
+      message: `Prisma generate failed to find the default schema. Did you include it in config.additionalFiles? ${terminalLink2(
+        "Config docs",
+        docs.config.prisma
+      )}
+Custom schema paths require a postinstall script like this: \`prisma generate --schema=./custom/path/to/schema.prisma\``,
+      shouldFail: true
     }
-  });
+  ];
+  const errorMessages2 = [];
+  const warningMessages = [];
+  let shouldFail = false;
+  for (const warning of warnings) {
+    const matches = logs.match(warning.regex);
+    if (!matches) {
+      continue;
+    }
+    const message = getMessageFromTemplate(warning.message, matches.groups);
+    if (warning.shouldFail) {
+      shouldFail = true;
+      errorMessages2.push(message);
+    } else {
+      warningMessages.push(message);
+    }
+  }
+  if (shouldFail) {
+    return {
+      ok: false,
+      summary: "Build succeeded with critical warnings. Will not proceed",
+      warnings: warningMessages,
+      errors: errorMessages2
+    };
+  }
+  return {
+    ok: true,
+    warnings: warningMessages
+  };
+}
+function checkLogsForErrors(logs) {
+  const errors = [
+    {
+      regex: /Error: Provided --schema at (?<schema>.*) doesn't exist/,
+      message: `Prisma generate failed to find the specified schema at "$schema".
+Did you include it in config.additionalFiles? ${terminalLink2(
+        "Config docs",
+        docs.config.prisma
+      )}`
+    },
+    {
+      regex: /sh: 1: (?<packageOrBinary>.*): not found/,
+      message: `$packageOrBinary not found
+
+If it's a package: Include it in ${terminalLink2(
+        "config.additionalPackages",
+        docs.config.prisma
+      )}
+If it's a binary:  Please ${terminalLink2(
+        "get in touch",
+        getInTouch
+      )} and we'll see what we can do!`
+    }
+  ];
+  for (const error of errors) {
+    const matches = logs.match(error.regex);
+    if (!matches) {
+      continue;
+    }
+    const message = getMessageFromTemplate(error.message, matches.groups);
+    log5.error(`${chalkError("Error:")} ${message}`);
+    break;
+  }
+}
+function getMessageFromTemplate(template, replacer) {
+  let message = template;
+  if (replacer) {
+    for (const [key, value] of Object.entries(replacer)) {
+      message = message.replaceAll(`$${key}`, value);
+    }
+  }
+  return message;
+}
+async function saveLogs(shortCode, logs) {
+  const logPath = join6(await createTempDir(), `build-${shortCode}.log`);
+  await writeFile2(logPath, logs);
+  return logPath;
+}
+async function failDeploy(shortCode, errorSummary, logs, deploymentSpinner, warnings, errors) {
+  deploymentSpinner.stop(`Failed to deploy project`);
+  if (logs.trim() !== "") {
+    const logPath = await saveLogs(shortCode, logs);
+    printWarnings(warnings);
+    printErrors(errors);
+    checkLogsForErrors(logs);
+    outro5(`${chalkError("Error:")} ${errorSummary}. Full build logs have been saved to ${logPath}`);
+  } else {
+    outro5(`${chalkError("Error:")} ${errorSummary}.`);
+  }
 }
 async function waitForDeploymentToFinish(deploymentId, client, timeoutInSeconds = 60) {
   return tracer.startActiveSpan("waitForDeploymentToFinish", async (span) => {
@@ -3227,7 +4140,7 @@ async function waitForDeploymentToFinish(deploymentId, client, timeoutInSeconds
     }
   });
 }
-async function buildAndPushImage(options) {
+async function buildAndPushImage(options, updater) {
   return tracer.startActiveSpan("buildAndPushImage", async (span) => {
     span.setAttributes({
       "options.registryHost": options.registryHost,
@@ -3283,15 +4196,24 @@ async function buildAndPushImage(options) {
     });
     const errors = [];
     try {
-      await new Promise((res, rej) => {
+      const processCode = await new Promise((res, rej) => {
         childProcess2.stderr?.on("data", (data) => {
-          const text2 = data.toString();
-          errors.push(text2);
-          logger.debug(text2);
+          const text3 = data.toString();
+          const lines = text3.split("\n").filter(Boolean);
+          errors.push(...lines);
+          logger.debug(text3);
         });
         childProcess2.on("error", (e) => rej(e));
-        childProcess2.on("close", () => res());
+        childProcess2.on("close", (code) => res(code));
       });
+      const logs = extractLogs(errors);
+      if (processCode !== 0) {
+        return {
+          ok: false,
+          error: `Error building image`,
+          logs
+        };
+      }
       const digest = extractImageDigest(errors);
       span.setAttributes({
         "image.digest": digest
@@ -3300,6 +4222,7 @@ async function buildAndPushImage(options) {
       return {
         ok: true,
         image: options.imageTag,
+        logs,
         digest
       };
     } catch (e) {
@@ -3307,7 +4230,8 @@ async function buildAndPushImage(options) {
       span.end();
       return {
         ok: false,
-        error: e instanceof Error ? e.message : JSON.stringify(e)
+        error: e instanceof Error ? e.message : JSON.stringify(e),
+        logs: extractLogs(errors)
       };
     }
   });
@@ -3353,15 +4277,22 @@ async function buildAndPushSelfHostedImage(options) {
     const errors = [];
     let digest;
     try {
-      await new Promise((res, rej) => {
+      const processCode = await new Promise((res, rej) => {
         buildProcess.stderr?.on("data", (data) => {
-          const text2 = data.toString();
-          errors.push(text2);
-          logger.debug(text2);
+          const text3 = data.toString();
+          errors.push(text3);
+          logger.debug(text3);
         });
         buildProcess.on("error", (e) => rej(e));
-        buildProcess.on("close", () => res());
+        buildProcess.on("close", (code) => res(code));
       });
+      if (processCode !== 0) {
+        return {
+          ok: false,
+          error: "Error building image",
+          logs: extractLogs(errors)
+        };
+      }
       digest = extractImageDigest(errors);
       span.setAttributes({
         "image.digest": digest
@@ -3371,7 +4302,8 @@ async function buildAndPushSelfHostedImage(options) {
       span.end();
       return {
         ok: false,
-        error: e instanceof Error ? e.message : JSON.stringify(e)
+        error: e instanceof Error ? e.message : JSON.stringify(e),
+        logs: extractLogs(errors)
       };
     }
     const pushArgs = ["push", imageRef].filter(Boolean);
@@ -3382,25 +4314,33 @@ async function buildAndPushSelfHostedImage(options) {
         cwd: options.cwd
       });
       try {
-        await new Promise((res, rej) => {
+        const processCode = await new Promise((res, rej) => {
           pushProcess.stdout?.on("data", (data) => {
-            const text2 = data.toString();
-            logger.debug(text2);
+            const text3 = data.toString();
+            logger.debug(text3);
           });
           pushProcess.stderr?.on("data", (data) => {
-            const text2 = data.toString();
-            logger.debug(text2);
+            const text3 = data.toString();
+            logger.debug(text3);
           });
           pushProcess.on("error", (e) => rej(e));
-          pushProcess.on("close", () => res());
+          pushProcess.on("close", (code) => res(code));
         });
+        if (processCode !== 0) {
+          return {
+            ok: false,
+            error: "Error pushing image",
+            logs: extractLogs(errors)
+          };
+        }
         span.end();
       } catch (e) {
         recordSpanException4(span, e);
         span.end();
         return {
           ok: false,
-          error: e instanceof Error ? e.message : JSON.stringify(e)
+          error: e instanceof Error ? e.message : JSON.stringify(e),
+          logs: extractLogs(errors)
         };
       }
     }
@@ -3408,21 +4348,25 @@ async function buildAndPushSelfHostedImage(options) {
     return {
       ok: true,
       image: options.imageTag,
-      digest
+      digest,
+      logs: extractLogs(errors)
     };
   });
 }
 function extractImageDigest(outputs) {
-  const imageDigestRegex = /sha256:[a-f0-9]{64}/;
+  const imageDigestRegex = /pushing manifest for .+(?<digest>sha256:[a-f0-9]{64})/;
   for (const line of outputs) {
-    if (line.includes("pushing manifest")) {
-      const imageDigestMatch = line.match(imageDigestRegex);
-      if (imageDigestMatch) {
-        return imageDigestMatch[0];
-      }
+    const imageDigestMatch = line.match(imageDigestRegex);
+    const digest = imageDigestMatch?.groups?.digest;
+    if (digest) {
+      return digest;
     }
   }
 }
+function extractLogs(outputs) {
+  const cleanedOutputs = outputs.map((line) => line.trim()).filter((line) => line !== "");
+  return cleanedOutputs.map((line) => line.trim()).join("\n");
+}
 async function compileProject(config, options, configPath) {
   return await tracer.startActiveSpan("compileProject", async (span) => {
     try {
@@ -3432,25 +4376,25 @@ async function compileProject(config, options, configPath) {
           throw new Error("Typecheck failed, aborting deployment");
         }
       }
-      const compileSpinner = spinner4();
+      const compileSpinner = spinner();
       compileSpinner.start(`Building project in ${config.projectDir}`);
       const taskFiles = await gatherTaskFiles(config);
       const workerFacade = readFileSync2(
-        new URL(importResolve("./workers/prod/worker-facade.js", import.meta.url)).href.replace(
-          "file://",
-          ""
-        ),
+        join6(cliRootPath(), "workers", "prod", "worker-facade.js"),
         "utf-8"
       );
-      const workerSetupPath = new URL(
-        importResolve("./workers/prod/worker-setup.js", import.meta.url)
-      ).href.replace("file://", "");
-      let workerContents = workerFacade.replace("__TASKS__", createTaskFileImports(taskFiles)).replace("__WORKER_SETUP__", `import { tracingSDK } from "${workerSetupPath}";`);
+      const workerSetupPath = join6(cliRootPath(), "workers", "prod", "worker-setup.js");
+      let workerContents = workerFacade.replace("__TASKS__", createTaskFileImports(taskFiles)).replace(
+        "__WORKER_SETUP__",
+        `import { tracingSDK } from "${escapeImportPath(workerSetupPath)}";`
+      );
       if (configPath) {
         logger.debug("Importing project config from", { configPath });
         workerContents = workerContents.replace(
           "__IMPORTED_PROJECT_CONFIG__",
-          `import * as importedConfigExports from "${configPath}"; const importedConfig = importedConfigExports.config; const handleError = importedConfigExports.handleError;`
+          `import * as importedConfigExports from "${escapeImportPath(
+            configPath
+          )}"; const importedConfig = importedConfigExports.config; const handleError = importedConfigExports.handleError;`
         );
       } else {
         workerContents = workerContents.replace(
@@ -3499,13 +4443,10 @@ async function compileProject(config, options, configPath) {
         throw new Error("Build failed, aborting deployment");
       }
       if (options.outputMetafile) {
-        await writeJSONFile(join4(options.outputMetafile, "worker.json"), result.metafile);
+        await writeJSONFile(join6(options.outputMetafile, "worker.json"), result.metafile);
       }
       const entryPointContents = readFileSync2(
-        new URL(importResolve("./workers/prod/entry-point.js", import.meta.url)).href.replace(
-          "file://",
-          ""
-        ),
+        join6(cliRootPath(), "workers", "prod", "entry-point.js"),
         "utf-8"
       );
       const entryPointResult = await build2({
@@ -3548,58 +4489,68 @@ async function compileProject(config, options, configPath) {
       }
       if (options.outputMetafile) {
         await writeJSONFile(
-          join4(options.outputMetafile, "entry-point.json"),
+          join6(options.outputMetafile, "entry-point.json"),
           entryPointResult.metafile
         );
       }
       const tempDir = await createTempDir();
       logger.debug(`Writing compiled files to ${tempDir}`);
-      const metaOutput = result.metafile.outputs[join4("out", "stdin.js")];
+      const metaOutput = result.metafile.outputs[posix.join("out", "stdin.js")];
       invariant(metaOutput, "Meta output for the result build is missing");
-      const entryPointMetaOutput = entryPointResult.metafile.outputs[join4("out", "stdin.js")];
+      const entryPointMetaOutput = entryPointResult.metafile.outputs[posix.join("out", "stdin.js")];
       invariant(entryPointMetaOutput, "Meta output for the entryPoint build is missing");
       const workerOutputFile = result.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js")
+        (file) => file.path === join6(config.projectDir, "out", "stdin.js")
       );
       invariant(workerOutputFile, "Output file for the result build is missing");
       const workerSourcemapFile = result.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js.map")
+        (file) => file.path === join6(config.projectDir, "out", "stdin.js.map")
       );
       invariant(workerSourcemapFile, "Sourcemap file for the result build is missing");
       const entryPointOutputFile = entryPointResult.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js")
+        (file) => file.path === join6(config.projectDir, "out", "stdin.js")
       );
       invariant(entryPointOutputFile, "Output file for the entryPoint build is missing");
       await writeFile2(
-        join4(tempDir, "worker.js"),
+        join6(tempDir, "worker.js"),
         `${workerOutputFile.text}
 //# sourceMappingURL=worker.js.map`
       );
-      await writeFile2(join4(tempDir, "worker.js.map"), workerSourcemapFile.text);
-      await writeFile2(join4(tempDir, "index.js"), entryPointOutputFile.text);
+      await writeFile2(join6(tempDir, "worker.js.map"), workerSourcemapFile.text);
+      await writeFile2(join6(tempDir, "index.js"), entryPointOutputFile.text);
       logger.debug("Getting the imports for the worker and entryPoint builds", {
         workerImports: metaOutput.imports,
         entryPointImports: entryPointMetaOutput.imports
       });
       const allImports = [...metaOutput.imports, ...entryPointMetaOutput.imports];
-      const externalPackageJson = await readJSONFile(join4(config.projectDir, "package.json"));
-      const dependencies2 = await gatherRequiredDependencies(
-        allImports,
-        config,
-        externalPackageJson
-      );
+      const javascriptProject = new JavascriptProject(config.projectDir);
+      const dependencies2 = await gatherRequiredDependencies(allImports, config, javascriptProject);
       const packageJsonContents = {
         name: "trigger-worker",
         version: "0.0.0",
         description: "",
         dependencies: dependencies2,
         scripts: {
-          postinstall: externalPackageJson?.scripts?.postinstall
+          ...javascriptProject.scripts
         }
       };
-      await writeJSONFile(join4(tempDir, "package.json"), packageJsonContents);
-      await copyAdditionalFiles(config, tempDir);
-      compileSpinner.stop("Project built successfully");
+      await writeJSONFile(join6(tempDir, "package.json"), packageJsonContents);
+      const copyResult = await copyAdditionalFiles(config, tempDir);
+      if (!copyResult.ok) {
+        compileSpinner.stop("Project built with warnings");
+        log5.warn(
+          `No additionalFiles matches for:
+
+${copyResult.noMatches.map((glob) => `- "${glob}"`).join("\n")}
+
+If this is unexpected you should check your ${terminalLink2(
+            "glob patterns",
+            "https://github.com/isaacs/node-glob?tab=readme-ov-file#glob-primer"
+          )} are valid.`
+        );
+      } else {
+        compileSpinner.stop("Project built successfully");
+      }
       const resolvingDependenciesResult = await resolveDependencies(
         tempDir,
         packageJsonContents,
@@ -3607,29 +4558,20 @@ async function compileProject(config, options, configPath) {
         options
       );
       if (!resolvingDependenciesResult) {
-        throw new Error("Failed to resolve dependencies");
+        throw new SkipLoggingError("Failed to resolve dependencies");
       }
-      const containerFilePath = new URL(
-        importResolve("./Containerfile.prod", import.meta.url)
-      ).href.replace("file://", "");
-      await copyFile(containerFilePath, join4(tempDir, "Containerfile"));
+      const containerFilePath = join6(cliRootPath(), "Containerfile.prod");
+      await copyFile(containerFilePath, join6(tempDir, "Containerfile"));
       const contentHasher = createHash("sha256");
       contentHasher.update(Buffer.from(entryPointOutputFile.text));
       contentHasher.update(Buffer.from(workerOutputFile.text));
       contentHasher.update(Buffer.from(JSON.stringify(dependencies2)));
       const contentHash = contentHasher.digest("hex");
-      const workerSetupEnvVars = await findAllEnvironmentVariableReferencesInFile(workerSetupPath);
-      const workerFacadeEnvVars = findAllEnvironmentVariableReferences(workerContents);
-      const envVars = findAllEnvironmentVariableReferences(workerOutputFile.text);
-      const finalEnvVars = envVars.filter(
-        (envVar) => !workerFacadeEnvVars.includes(envVar) && !workerSetupEnvVars.includes(envVar)
-      );
       span.setAttributes({
-        contentHash,
-        envVars: finalEnvVars
+        contentHash
       });
       span.end();
-      return { path: tempDir, contentHash, envVars: finalEnvVars };
+      return { path: tempDir, contentHash };
     } catch (e) {
       recordSpanException4(span, e);
       span.end();
@@ -3639,13 +4581,13 @@ async function compileProject(config, options, configPath) {
 }
 async function resolveDependencies(projectDir, packageJsonContents, config, options) {
   return await tracer.startActiveSpan("resolveDependencies", async (span) => {
-    const resolvingDepsSpinner = spinner4();
+    const resolvingDepsSpinner = spinner();
     resolvingDepsSpinner.start("Resolving dependencies");
     const hasher = createHash("sha256");
     hasher.update(JSON.stringify(packageJsonContents));
     const digest = hasher.digest("hex").slice(0, 16);
-    const cacheDir = join4(config.projectDir, ".trigger", "cache");
-    const cachePath = join4(cacheDir, `${digest}.json`);
+    const cacheDir = join6(config.projectDir, ".trigger", "cache");
+    const cachePath = join6(cacheDir, `${digest}.json`);
     span.setAttributes({
       "packageJson.digest": digest,
       "cache.path": cachePath,
@@ -3654,7 +4596,7 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
     try {
       const cachedPackageLock = await readFile2(cachePath, "utf-8");
       logger.debug(`Using cached package-lock.json for ${digest}`);
-      await writeFile2(join4(projectDir, "package-lock.json"), cachedPackageLock);
+      await writeFile2(join6(projectDir, "package-lock.json"), cachedPackageLock);
       span.setAttributes({
         "cache.hit": true
       });
@@ -3677,21 +4619,44 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
           cwd: projectDir,
           stdio: logger.loggerLevel === "debug" ? "inherit" : "pipe"
         });
-        const packageLockContents = await readFile2(join4(projectDir, "package-lock.json"), "utf-8");
+        const packageLockContents = await readFile2(join6(projectDir, "package-lock.json"), "utf-8");
         logger.debug(`Writing package-lock.json to cache for ${digest}`);
         await mkdir(cacheDir, { recursive: true });
         await writeFile2(cachePath, packageLockContents);
-        await writeFile2(join4(projectDir, "package-lock.json"), packageLockContents);
+        await writeFile2(join6(projectDir, "package-lock.json"), packageLockContents);
         span.end();
         resolvingDepsSpinner.stop("Dependencies resolved");
         return true;
       } catch (installError) {
-        logger.debug(`Failed to resolve dependencies: ${JSON.stringify(installError)}`);
         recordSpanException4(span, installError);
         span.end();
-        resolvingDepsSpinner.stop(
-          "Failed to resolve dependencies. Rerun with --log-level=debug for more information"
-        );
+        const parsedError = parseNpmInstallError(installError);
+        if (typeof parsedError === "string") {
+          resolvingDepsSpinner.stop(`Failed to resolve dependencies: ${parsedError}`);
+        } else {
+          switch (parsedError.type) {
+            case "package-not-found-error": {
+              resolvingDepsSpinner.stop(`Failed to resolve dependencies`);
+              logger.log(
+                `
+${chalkError("X Error:")} The package ${chalkPurple(
+                  parsedError.packageName
+                )} could not be found in the npm registry.`
+              );
+              break;
+            }
+            case "no-matching-version-error": {
+              resolvingDepsSpinner.stop(`Failed to resolve dependencies`);
+              logger.log(
+                `
+${chalkError("X Error:")} The package ${chalkPurple(
+                  parsedError.packageName
+                )} could not resolve because the version doesn't exist`
+              );
+              break;
+            }
+          }
+        }
         return false;
       }
     }
@@ -3700,7 +4665,7 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
 async function typecheckProject(config, options) {
   return await tracer.startActiveSpan("typecheckProject", async (span) => {
     try {
-      const typecheckSpinner = spinner4();
+      const typecheckSpinner = spinner();
       typecheckSpinner.start("Typechecking project");
       const tscTypecheck = execa2("npm", ["exec", "tsc", "--", "--noEmit"], {
         cwd: config.projectDir
@@ -3710,8 +4675,8 @@ async function typecheckProject(config, options) {
       tscTypecheck.stdout?.on("data", (chunk) => stdouts.push(chunk.toString()));
       tscTypecheck.stderr?.on("data", (chunk) => stderrs.push(chunk.toString()));
       try {
-        await new Promise((resolve4, reject) => {
-          tscTypecheck.addListener("exit", (code) => code === 0 ? resolve4(code) : reject(code));
+        await new Promise((resolve5, reject) => {
+          tscTypecheck.addListener("exit", (code) => code === 0 ? resolve5(code) : reject(code));
         });
       } catch (error) {
         typecheckSpinner.stop(
@@ -3735,7 +4700,7 @@ async function typecheckProject(config, options) {
     }
   });
 }
-async function gatherRequiredDependencies(imports, config, projectPackageJson) {
+async function gatherRequiredDependencies(imports, config, project) {
   const dependencies2 = {};
   for (const file of imports) {
     if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
@@ -3745,7 +4710,7 @@ async function gatherRequiredDependencies(imports, config, projectPackageJson) {
     if (dependencies2[packageName]) {
       continue;
     }
-    const externalDependencyVersion = (projectPackageJson?.dependencies ?? {})[packageName];
+    const externalDependencyVersion = await project.resolve(packageName);
     if (externalDependencyVersion) {
       dependencies2[packageName] = stripWorkspaceFromVersion(externalDependencyVersion);
       continue;
@@ -3765,16 +4730,17 @@ async function gatherRequiredDependencies(imports, config, projectPackageJson) {
         dependencies2[packageParts.name] = packageParts.version;
         continue;
       } else {
-        const externalDependencyVersion = {
-          ...projectPackageJson?.devDependencies,
-          ...projectPackageJson?.dependencies
-        }[packageName];
+        const externalDependencyVersion = await project.resolve(packageParts.name, {
+          allowDev: true
+        });
         if (externalDependencyVersion) {
           dependencies2[packageParts.name] = externalDependencyVersion;
           continue;
         } else {
-          logger.warn(
-            `Could not find version for package ${packageName}, add a version specifier to the package name (e.g. ${packageParts.name}@latest) or add it to your project's package.json`
+          logger.log(
+            `${chalkWarning("X Warning:")} Could not find version for package ${chalkPurple(
+              packageName
+            )}, add a version specifier to the package name (e.g. ${packageParts.name}@latest) or add it to your project's package.json`
           );
         }
       }
@@ -3784,8 +4750,9 @@ async function gatherRequiredDependencies(imports, config, projectPackageJson) {
 }
 async function copyAdditionalFiles(config, tempDir) {
   const additionalFiles = config.additionalFiles ?? [];
+  const noMatches = [];
   if (additionalFiles.length === 0) {
-    return;
+    return { ok: true };
   }
   return await tracer.startActiveSpan(
     "copyAdditionalFiles",
@@ -3799,22 +4766,55 @@ async function copyAdditionalFiles(config, tempDir) {
         logger.debug(`Copying files to ${tempDir}`, {
           additionalFiles
         });
-        const glob = new Glob(additionalFiles, {
+        const globOptions = {
           withFileTypes: true,
           ignore: ["node_modules"],
           cwd: config.projectDir,
           nodir: true
-        });
-        for await (const file of glob) {
-          const relativeDestinationPath = join4(
-            tempDir,
-            relative2(config.projectDir, file.fullpath())
-          );
-          logger.debug(`Copying file ${file.fullpath()} to ${relativeDestinationPath}`);
-          await mkdir(dirname(relativeDestinationPath), { recursive: true });
-          await copyFile(file.fullpath(), relativeDestinationPath);
+        };
+        const globs = [];
+        let i = 0;
+        for (const additionalFile of additionalFiles) {
+          let glob;
+          if (i === 0) {
+            glob = new Glob(additionalFile, globOptions);
+          } else {
+            const previousGlob = globs[i - 1];
+            if (!previousGlob) {
+              logger.error("No previous glob, this shouldn't happen", { i, additionalFiles });
+              continue;
+            }
+            glob = new Glob(additionalFile, previousGlob);
+          }
+          if (!(Symbol.asyncIterator in glob)) {
+            logger.error("Glob should be an async iterator", { glob });
+            throw new Error("Unrecoverable error while copying additional files");
+          }
+          let matches = 0;
+          for await (const file of glob) {
+            matches++;
+            const pathInsideTempDir = relative3(config.projectDir, file.fullpath()).split(posix.sep).filter((p) => p !== "..").join(posix.sep);
+            const relativeDestinationPath = join6(tempDir, pathInsideTempDir);
+            logger.debug(`Copying file ${file.fullpath()} to ${relativeDestinationPath}`);
+            await mkdir(dirname(relativeDestinationPath), { recursive: true });
+            await copyFile(file.fullpath(), relativeDestinationPath);
+          }
+          if (matches === 0) {
+            noMatches.push(additionalFile);
+          }
+          globs[i] = glob;
+          i++;
         }
         span.end();
+        if (noMatches.length > 0) {
+          return {
+            ok: false,
+            noMatches
+          };
+        }
+        return {
+          ok: true
+        };
       } catch (error) {
         recordSpanException4(span, error);
         span.end();
@@ -3825,7 +4825,7 @@ async function copyAdditionalFiles(config, tempDir) {
 }
 async function ensureLoggedIntoDockerRegistry(registryHost, auth) {
   const tmpDir = await createTempDir();
-  const dockerConfigPath = join4(tmpDir, "config.json");
+  const dockerConfigPath = join6(tmpDir, "config.json");
   await writeJSONFile(dockerConfigPath, {
     auths: {
       [registryHost]: {
@@ -3836,43 +4836,20 @@ async function ensureLoggedIntoDockerRegistry(registryHost, auth) {
   logger.debug(`Writing docker config to ${dockerConfigPath}`);
   return tmpDir;
 }
-async function findAllEnvironmentVariableReferencesInFile(filePath) {
-  const fileContents = await readFile2(filePath, "utf-8");
-  return findAllEnvironmentVariableReferences(fileContents);
-}
-var IGNORED_ENV_VARS = ["NODE_ENV", "SHELL", "HOME", "PWD", "LOGNAME", "USER", "PATH", "DEBUG"];
-function findAllEnvironmentVariableReferences(code) {
-  const regex = /\bprocess\.env\.([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
-  const matches = code.matchAll(regex);
-  const matchesArray = Array.from(matches, (match) => match[1]).filter(Boolean);
-  const filteredMatches = matchesArray.filter((match) => !IGNORED_ENV_VARS.includes(match));
-  return Array.from(new Set(filteredMatches));
-}
-function arrayToSentence(items) {
-  if (items.length === 1 && typeof items[0] === "string") {
-    return items[0];
-  }
-  if (items.length === 2) {
-    return `${items[0]} and ${items[1]}`;
-  }
-  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
-}
 
 // src/commands/dev.tsx
 import {
-  ZodMessageHandler as ZodMessageHandler2,
-  ZodMessageSender as ZodMessageSender2,
   clientWebsocketMessages,
   detectDependencyVersion as detectDependencyVersion2,
   serverWebsocketMessages
 } from "@trigger.dev/core/v3";
+import { ZodMessageHandler as ZodMessageHandler2, ZodMessageSender as ZodMessageSender2 } from "@trigger.dev/core/v3/zodMessageHandler";
 import { watch } from "chokidar";
 import { context as context2 } from "esbuild";
-import { resolve as importResolve2 } from "import-meta-resolve";
 import { render, useInput } from "ink";
 import { createHash as createHash2 } from "node:crypto";
 import fs7, { readFileSync as readFileSync3 } from "node:fs";
-import { basename, dirname as dirname3, join as join5 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join7, normalize } from "node:path";
 import pDebounce from "p-debounce";
 import { WebSocket } from "partysocket";
 import React, { Suspense, useEffect } from "react";
@@ -3888,23 +4865,30 @@ var UncaughtExceptionError = class extends Error {
     this.name = "UncaughtExceptionError";
   }
 };
+var TaskMetadataParseError = class extends Error {
+  constructor(zodIssues, tasks) {
+    super(`Failed to parse task metadata`);
+    this.zodIssues = zodIssues;
+    this.tasks = tasks;
+    this.name = "TaskMetadataParseError";
+  }
+};
 
 // src/workers/dev/backgroundWorker.ts
 import {
   SemanticInternalAttributes,
   TaskRunErrorCodes,
-  ZodMessageHandler,
-  ZodMessageSender,
   childToWorkerMessages,
   correctErrorStackTrace,
   formatDurationMilliseconds,
   workerToChildMessages
 } from "@trigger.dev/core/v3";
+import { ZodMessageHandler, ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
 import dotenv from "dotenv";
 import { Evt } from "evt";
 import { fork } from "node:child_process";
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
-import terminalLink2 from "terminal-link";
+import { dirname as dirname2, resolve as resolve3 } from "node:path";
+import terminalLink3 from "terminal-link";
 var BackgroundWorkerCoordinator = class {
   constructor(baseURL) {
     this.baseURL = baseURL;
@@ -3989,7 +4973,7 @@ var BackgroundWorkerCoordinator = class {
     const logsUrl = `${this.baseURL}/runs/${execution.run.id}`;
     const pipe = chalkGrey("|");
     const bullet = chalkGrey("\u25CB");
-    const link = chalkLink(terminalLink2("View logs", logsUrl));
+    const link = chalkLink(terminalLink3("View logs", logsUrl));
     let timestampPrefix = chalkGrey(prettyPrintDate(payload.execution.attempt.startedAt));
     const workerPrefix = chalkWorker(record.version);
     const taskPrefix = chalkTask(execution.task.id);
@@ -4062,8 +5046,8 @@ var CancelledProcessError = class extends Error {
   }
 };
 var BackgroundWorker = class {
-  constructor(path6, params) {
-    this.path = path6;
+  constructor(path7, params) {
+    this.path = path7;
     this.params = params;
   }
   _initialized = false;
@@ -4097,7 +5081,13 @@ var BackgroundWorker = class {
       await installPackages(this.params.dependencies, { cwd: dirname2(this.path) });
     }
     let resolved = false;
-    this.tasks = await new Promise((resolve4, reject) => {
+    const cwd = dirname2(this.path);
+    const fullEnv = {
+      ...this.params.env,
+      ...this.#readEnvVars()
+    };
+    logger.debug("Initializing worker", { path: this.path, cwd, fullEnv });
+    this.tasks = await new Promise((resolve5, reject) => {
       const child = fork(this.path, {
         stdio: [
           /*stdin*/
@@ -4108,10 +5098,8 @@ var BackgroundWorker = class {
           "pipe",
           "ipc"
         ],
-        env: {
-          ...this.params.env,
-          ...this.#readEnvVars()
-        }
+        cwd,
+        env: fullEnv
       });
       const timeout = setTimeout(() => {
         if (resolved) {
@@ -4126,13 +5114,18 @@ var BackgroundWorker = class {
         if (message.type === "TASKS_READY" && !resolved) {
           clearTimeout(timeout);
           resolved = true;
-          resolve4(message.payload.tasks);
+          resolve5(message.payload.tasks);
           child.kill();
         } else if (message.type === "UNCAUGHT_EXCEPTION") {
           clearTimeout(timeout);
           resolved = true;
           reject(new UncaughtExceptionError(message.payload.error, message.payload.origin));
           child.kill();
+        } else if (message.type === "TASKS_FAILED_TO_PARSE") {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(new TaskMetadataParseError(message.payload.zodIssues, message.payload.tasks));
+          child.kill();
         }
       });
       child.on("exit", (code) => {
@@ -4142,6 +5135,9 @@ var BackgroundWorker = class {
           reject(new Error(`Worker exited with code ${code}`));
         }
       });
+      child.stdout?.on("data", (data) => {
+        logger.log(data.toString());
+      });
     });
     this._initialized = true;
   }
@@ -4158,7 +5154,7 @@ var BackgroundWorker = class {
     }
     if (!this._taskRunProcesses.has(payload.execution.run.id)) {
       const taskRunProcess = new TaskRunProcess(
-        payload.execution.run.id,
+        payload.execution,
         this.path,
         {
           ...this.params.env,
@@ -4253,7 +5249,7 @@ var BackgroundWorker = class {
     const result = {};
     dotenv.config({
       processEnv: result,
-      path: [".env", ".env.local", ".env.development.local"].map((p) => resolve2(process.cwd(), p))
+      path: [".env", ".env.local", ".env.development.local"].map((p) => resolve3(process.cwd(), p))
     });
     process.env.TRIGGER_API_URL && (result.TRIGGER_API_URL = process.env.TRIGGER_API_URL);
     delete result.TRIGGER_API_URL;
@@ -4268,9 +5264,9 @@ var BackgroundWorker = class {
   }
 };
 var TaskRunProcess = class {
-  constructor(runId, path6, env, metadata, worker) {
-    this.runId = runId;
-    this.path = path6;
+  constructor(execution, path7, env, metadata, worker) {
+    this.execution = execution;
+    this.path = path7;
     this.env = env;
     this.metadata = metadata;
     this.worker = worker;
@@ -4300,9 +5296,20 @@ var TaskRunProcess = class {
     await this.cleanup(true);
   }
   async initialize() {
-    logger.debug(`[${this.runId}] initializing task run process`, {
-      env: this.env,
-      path: this.path
+    const fullEnv = {
+      ...this.execution.run.isTest ? { TRIGGER_LOG_LEVEL: "debug" } : {},
+      ...this.env,
+      OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
+        [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
+      }),
+      OTEL_EXPORTER_OTLP_COMPRESSION: "none",
+      ...this.worker.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
+    };
+    const cwd = dirname2(this.path);
+    logger.debug(`[${this.execution.run.id}] initializing task run process`, {
+      env: fullEnv,
+      path: this.path,
+      cwd
     });
     this._child = fork(this.path, {
       stdio: [
@@ -4314,15 +5321,8 @@ var TaskRunProcess = class {
         "pipe",
         "ipc"
       ],
-      cwd: dirname2(this.path),
-      env: {
-        ...this.env,
-        OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
-          [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
-        }),
-        OTEL_EXPORTER_OTLP_COMPRESSION: "none",
-        ...this.worker.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
-      },
+      cwd,
+      env: fullEnv,
       execArgv: this.worker.debuggerOn ? ["--inspect-brk", "--trace-uncaught", "--no-warnings=ExperimentalWarning"] : ["--trace-uncaught", "--no-warnings=ExperimentalWarning"]
     });
     this._child.on("message", this.#handleMessage.bind(this));
@@ -4334,18 +5334,24 @@ var TaskRunProcess = class {
     if (kill && this._isBeingKilled) {
       return;
     }
-    logger.debug(`[${this.runId}] cleaning up task run process`, { kill });
+    logger.debug(`[${this.execution.run.id}] cleaning up task run process`, { kill });
     await this._sender.send("CLEANUP", {
       flush: true,
       kill
     });
     this._isBeingKilled = kill;
+    setTimeout(() => {
+      if (this._child && !this._child.killed) {
+        logger.debug(`[${this.execution.run.id}] killing task run process after timeout`);
+        this._child.kill();
+      }
+    }, 5e3);
   }
   async executeTaskRun(payload) {
     let resolver;
     let rejecter;
-    const promise = new Promise((resolve4, reject) => {
-      resolver = resolve4;
+    const promise = new Promise((resolve5, reject) => {
+      resolver = resolve5;
       rejecter = reject;
     });
     this._attemptStatuses.set(payload.execution.attempt.id, "PENDING");
@@ -4365,10 +5371,13 @@ var TaskRunProcess = class {
     if (!completion.ok && typeof completion.retry !== "undefined") {
       return;
     }
-    if (execution.run.id === this.runId) {
+    if (execution.run.id === this.execution.run.id) {
       return;
     }
-    logger.debug(`[${this.runId}] task run completed notification`, { completion, execution });
+    logger.debug(`[${this.execution.run.id}] task run completed notification`, {
+      completion,
+      execution
+    });
     this._sender.send("TASK_RUN_COMPLETED_NOTIFICATION", {
       completion,
       execution
@@ -4393,6 +5402,7 @@ var TaskRunProcess = class {
         break;
       }
       case "READY_TO_DISPOSE": {
+        logger.debug(`[${this.execution.run.id}] task run process is ready to dispose`);
         this.#kill();
         break;
       }
@@ -4406,7 +5416,7 @@ var TaskRunProcess = class {
     }
   }
   async #handleExit(code) {
-    logger.debug(`[${this.runId}] task run process exiting`, { code });
+    logger.debug(`[${this.execution.run.id}] task run process exiting`, { code });
     for (const [id, status] of this._attemptStatuses.entries()) {
       if (status === "PENDING") {
         this._attemptStatuses.set(id, "REJECTED");
@@ -4428,10 +5438,14 @@ var TaskRunProcess = class {
   }
   #handleLog(data) {
     if (!this._currentExecution) {
+      logger.log(`${chalkGrey("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${data.toString()}`);
       return;
     }
+    const runId = chalkRun(
+      `${this._currentExecution.run.id}.${this._currentExecution.attempt.number}`
+    );
     logger.log(
-      `[${this.metadata.version}][${this._currentExecution.run.id}.${this._currentExecution.attempt.number}] ${data.toString()}`
+      `${chalkGrey("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${runId} ${data.toString()}`
     );
   }
   #handleStdErr(data) {
@@ -4439,63 +5453,105 @@ var TaskRunProcess = class {
       return;
     }
     if (!this._currentExecution) {
-      logger.error(`[${this.metadata.version}] ${data.toString()}`);
+      logger.log(`${chalkError("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${data.toString()}`);
       return;
     }
-    logger.error(
-      `[${this.metadata.version}][${this._currentExecution.run.id}.${this._currentExecution.attempt.number}] ${data.toString()}`
+    const runId = chalkRun(
+      `${this._currentExecution.run.id}.${this._currentExecution.attempt.number}`
+    );
+    logger.log(
+      `${chalkError("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${runId} ${data.toString()}`
     );
   }
   #kill() {
     if (this._child && !this._child.killed) {
+      logger.debug(`[${this.execution.run.id}] killing task run process`);
       this._child?.kill();
     }
   }
 };
 
+// src/utilities/runtimeCheck.ts
+function runtimeCheck(minimumMajor, minimumMinor) {
+  if (typeof process === "undefined") {
+    throw "The dev CLI can only be run in a Node.js compatible environment";
+  }
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  const isBun = typeof process.versions.bun === "string";
+  if (major < minimumMajor || major === minimumMajor && minor < minimumMinor) {
+    if (isBun) {
+      throw `The dev CLI requires at least Node.js ${minimumMajor}.${minimumMinor}. You are running Bun ${process.versions.bun}, which is compatible with Node.js ${process.versions.node}`;
+    } else {
+      throw `The dev CLI requires at least Node.js ${minimumMajor}.${minimumMinor}. You are running Node.js ${process.versions.node}`;
+    }
+  }
+  logger.debug(
+    `Node.js version: ${process.versions.node}${isBun ? ` (Bun ${process.versions.bun})` : ""}`
+  );
+}
+
 // src/commands/dev.tsx
+import { findUp as findUp3, pathExists as pathExists2 } from "find-up";
 var apiClient;
 var DevCommandOptions = CommonCommandOptions.extend({
   debugger: z5.boolean().default(false),
   debugOtel: z5.boolean().default(false),
   config: z5.string().optional(),
-  projectRef: z5.string().optional()
+  projectRef: z5.string().optional(),
+  skipUpdateCheck: z5.boolean().default(false)
 });
 function configureDevCommand(program2) {
   return commonOptions(
-    program2.command("dev").description("Run your Trigger.dev tasks locally").argument("[path]", "The path to the project", ".").option("-c, --config <config file>", "The name of the config file, found at [path]").option(
+    program2.command("dev").description("Run your Trigger.dev tasks locally").argument("[path]", "The path to the project", ".").option("-c, --config <config file>", "The name of the config file, found at [path].").option(
       "-p, --project-ref <project ref>",
       "The project ref. Required if there is no config file."
-    ).option("--debugger", "Enable the debugger").option("--debug-otel", "Enable OpenTelemetry debugging")
-  ).action(async (path6, options) => {
+    ).option("--debugger", "Enable the debugger").option("--debug-otel", "Enable OpenTelemetry debugging").option("--skip-update-check", "Skip checking for @trigger.dev package updates")
+  ).action(async (path7, options) => {
     wrapCommandAction("dev", DevCommandOptions, options, async (opts) => {
-      await devCommand(path6, opts);
+      await devCommand(path7, opts);
     });
   });
 }
+var MINIMUM_NODE_MAJOR = 18;
+var MINIMUM_NODE_MINOR = 16;
 async function devCommand(dir, options) {
+  try {
+    runtimeCheck(MINIMUM_NODE_MAJOR, MINIMUM_NODE_MINOR);
+  } catch (e) {
+    logger.log(`${chalkError("X Error:")} ${e}`);
+    process.exitCode = 1;
+    return;
+  }
   const authorization = await isLoggedIn(options.profile);
   if (!authorization.ok) {
     if (authorization.error === "fetch failed") {
-      logger.error("Fetch failed. Platform down?");
+      logger.log(
+        `${chalkError(
+          "X Error:"
+        )} Connecting to the server failed. Please check your internet connection or contact eric@trigger.dev for help.`
+      );
     } else {
-      logger.error("You must login first. Use `trigger.dev login` to login.");
+      logger.log(`${chalkError("X Error:")} You must login first. Use the \`login\` CLI command.`);
     }
     process.exitCode = 1;
     return;
   }
-  const devInstance = await startDev(dir, options, authorization.auth);
+  const devInstance = await startDev(dir, options, authorization.auth, authorization.dashboardUrl);
   const { waitUntilExit } = devInstance.devReactElement;
   await waitUntilExit();
 }
-async function startDev(dir, options, authorization) {
+async function startDev(dir, options, authorization, dashboardUrl) {
   let rerender;
   try {
     if (options.logLevel) {
       logger.loggerLevel = options.logLevel;
     }
     await printStandloneInitialBanner(true);
-    printDevBanner();
+    let displayedUpdateMessage = false;
+    if (!options.skipUpdateCheck) {
+      displayedUpdateMessage = await updateTriggerPackages(dir, { ...options }, true, true);
+    }
+    printDevBanner(displayedUpdateMessage);
     logger.debug("Starting dev session", { dir, options, authorization });
     let config = await readConfig(dir, {
       projectRef: options.projectRef,
@@ -4526,6 +5582,7 @@ async function startDev(dir, options, authorization) {
       return /* @__PURE__ */ React.createElement(
         DevUI,
         {
+          dashboardUrl,
           config: configParam,
           apiUrl,
           apiKey: devEnv.data.apiKey,
@@ -4557,6 +5614,7 @@ async function startDev(dir, options, authorization) {
 }
 function useDev({
   config,
+  dashboardUrl,
   apiUrl,
   apiKey,
   environmentClient,
@@ -4586,7 +5644,7 @@ function useDev({
       }
     });
     const backgroundWorkerCoordinator = new BackgroundWorkerCoordinator(
-      `${apiUrl}/projects/v3/${config.project}`
+      `${dashboardUrl}/projects/v3/${config.project}`
     );
     websocket.addEventListener("open", async (event) => {
     });
@@ -4658,22 +5716,21 @@ function useDev({
       }
       let latestWorkerContentHash;
       const taskFiles = await gatherTaskFiles(config);
-      const workerFacade = readFileSync3(
-        new URL(importResolve2("./workers/dev/worker-facade.js", import.meta.url)).href.replace(
-          "file://",
-          ""
-        ),
-        "utf-8"
+      const workerFacadePath = join7(cliRootPath(), "workers", "dev", "worker-facade.js");
+      const workerFacade = readFileSync3(workerFacadePath, "utf-8");
+      const workerSetupPath = join7(cliRootPath(), "workers", "dev", "worker-setup.js");
+      let entryPointContents = workerFacade.replace("__TASKS__", createTaskFileImports(taskFiles)).replace(
+        "__WORKER_SETUP__",
+        `import { tracingSDK, sender } from "${escapeImportPath(workerSetupPath)}";`
       );
-      const workerSetupPath = new URL(
-        importResolve2("./workers/dev/worker-setup.js", import.meta.url)
-      ).href.replace("file://", "");
-      let entryPointContents = workerFacade.replace("__TASKS__", createTaskFileImports(taskFiles)).replace("__WORKER_SETUP__", `import { tracingSDK, sender } from "${workerSetupPath}";`);
       if (configPath) {
+        configPath = normalize(configPath);
         logger.debug("Importing project config from", { configPath });
         entryPointContents = entryPointContents.replace(
           "__IMPORTED_PROJECT_CONFIG__",
-          `import * as importedConfigExports from "${configPath}"; const importedConfig = importedConfigExports.config; const handleError = importedConfigExports.handleError;`
+          `import * as importedConfigExports from "${escapeImportPath(
+            configPath
+          )}"; const importedConfig = importedConfigExports.config; const handleError = importedConfigExports.handleError;`
         );
       } else {
         entryPointContents = entryPointContents.replace(
@@ -4706,6 +5763,7 @@ function useDev({
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
+          bundleTriggerDevCore("workerFacade", config.tsconfigPath),
           bundleDependenciesPlugin(
             "workerFacade",
             (config.dependenciesToBundle ?? []).concat([/^@trigger.dev/]),
@@ -4725,19 +5783,19 @@ function useDev({
                 if (!firstBuild) {
                   logger.log(chalkGrey("\u25CB Building background worker\u2026"));
                 }
-                const metaOutputKey = join5("out", `stdin.js`);
+                const metaOutputKey = join7("out", `stdin.js`).replace(/\\/g, "/");
                 const metaOutput = result.metafile.outputs[metaOutputKey];
                 if (!metaOutput) {
                   throw new Error(`Could not find metafile`);
                 }
-                const outputFileKey = join5(config.projectDir, metaOutputKey);
+                const outputFileKey = join7(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 = join5(config.projectDir, `${metaOutputKey}.map`);
+                const sourceMapFileKey = join7(config.projectDir, `${metaOutputKey}.map`);
                 const sourceMapFile = result.outputFiles.find(
                   (file) => file.path === sourceMapFileKey
                 );
@@ -4748,10 +5806,10 @@ function useDev({
                   logger.log(chalkGrey("\u25CB No changes detected, skipping build\u2026"));
                   return;
                 }
-                const fullPath = join5(config.projectDir, ".trigger", `${contentHash}.js`);
+                const fullPath = join7(config.projectDir, ".trigger", `${contentHash}.js`);
                 const sourceMapPath = `${fullPath}.map`;
                 const outputFileWithSourceMap = `${outputFile.text}
-//# sourceMappingURL=${basename(sourceMapPath)}`;
+//# sourceMappingURL=${basename2(sourceMapPath)}`;
                 await fs7.promises.mkdir(dirname3(fullPath), { recursive: true });
                 await fs7.promises.writeFile(fullPath, outputFileWithSourceMap);
                 logger.debug(`Wrote background worker to ${fullPath}`);
@@ -4761,7 +5819,7 @@ function useDev({
                   await fs7.promises.writeFile(sourceMapPath2, sourceMapFile.text);
                 }
                 const environmentVariablesResponse = await environmentClient.getEnvironmentVariables(config.project);
-                const processEnv = gatherProcessEnv();
+                const processEnv = await gatherProcessEnv();
                 const backgroundWorker = new BackgroundWorker(fullPath, {
                   projectConfig: config,
                   dependencies: dependencies2,
@@ -4779,8 +5837,15 @@ function useDev({
                   latestWorkerContentHash = contentHash;
                   let packageVersion;
                   const taskResources = [];
-                  if (!backgroundWorker.tasks) {
-                    throw new Error(`Background Worker started without tasks`);
+                  if (!backgroundWorker.tasks || backgroundWorker.tasks.length === 0) {
+                    logger.log(
+                      `${chalkError(
+                        "X Error:"
+                      )} Worker failed to build: no tasks found. Searched in ${config.triggerDirectories.join(
+                        ", "
+                      )}`
+                    );
+                    return;
                   }
                   for (const task of backgroundWorker.tasks) {
                     taskResources.push(task);
@@ -4799,6 +5864,9 @@ function useDev({
                     );
                     return;
                   }
+                  logger.debug("Creating background worker with tasks", {
+                    tasks: taskResources
+                  });
                   const backgroundWorkerBody = {
                     localOnly: true,
                     metadata: {
@@ -4829,17 +5897,52 @@ function useDev({
                     backgroundWorker
                   );
                 } catch (e) {
-                  if (e instanceof UncaughtExceptionError) {
+                  if (e instanceof TaskMetadataParseError) {
+                    logTaskMetadataParseError(e.zodIssues, e.tasks);
+                    return;
+                  } else if (e instanceof UncaughtExceptionError) {
+                    const parsedBuildError = parseBuildErrorStack(e.originalError);
+                    if (parsedBuildError && typeof parsedBuildError !== "string") {
+                      logESMRequireError(
+                        parsedBuildError,
+                        configPath ? { status: "file", path: configPath, config } : { status: "in-memory", config }
+                      );
+                      return;
+                    } else {
+                    }
                     if (e.originalError.stack) {
-                      logger.error("Background worker failed to start", e.originalError.stack);
+                      logger.log(
+                        `${chalkError("X Error:")} Worker failed to start`,
+                        e.originalError.stack
+                      );
                     }
                     return;
                   }
-                  if (e instanceof Error) {
-                    logger.error(`Background worker failed to start`, e.stack);
-                    return;
+                  const parsedError = parseNpmInstallError(e);
+                  if (typeof parsedError === "string") {
+                    logger.log(`${chalkError("X Error:")} ${parsedError}`);
+                  } else {
+                    switch (parsedError.type) {
+                      case "package-not-found-error": {
+                        logger.log(
+                          `
+${chalkError("X Error:")} The package ${chalkPurple(
+                            parsedError.packageName
+                          )} could not be found in the npm registry.`
+                        );
+                        break;
+                      }
+                      case "no-matching-version-error": {
+                        logger.log(
+                          `
+${chalkError("X Error:")} The package ${chalkPurple(
+                            parsedError.packageName
+                          )} could not resolve because the version doesn't exist`
+                        );
+                        break;
+                      }
+                    }
                   }
-                  logger.error(`Background worker failed to start: ${e}`);
                 }
               });
             }
@@ -4850,17 +5953,17 @@ function useDev({
     }
     const throttledRebuild = pDebounce(runBuild, 250, { before: true });
     const taskFileWatcher = watch(
-      config.triggerDirectories.map((triggerDir) => `${triggerDir}/*.ts`),
+      config.triggerDirectories.map((triggerDir) => `${triggerDir}/**/*.ts`),
       {
         ignoreInitial: true
       }
     );
-    taskFileWatcher.on("add", async (path6) => {
+    taskFileWatcher.on("add", async (path7) => {
       throttledRebuild().catch((error) => {
         logger.error(error);
       });
     });
-    taskFileWatcher.on("unlink", async (path6) => {
+    taskFileWatcher.on("unlink", async (path7) => {
       throttledRebuild().catch((error) => {
         logger.error(error);
       });
@@ -4920,7 +6023,7 @@ async function gatherRequiredDependencies2(outputMeta, config) {
     }
   }
   if (config.additionalPackages) {
-    const projectPackageJson = await readJSONFile(join5(config.projectDir, "package.json"));
+    const projectPackageJson = await readJSONFile(join7(config.projectDir, "package.json"));
     for (const packageName of config.additionalPackages) {
       if (dependencies2[packageName]) {
         continue;
@@ -4950,16 +6053,14 @@ async function gatherRequiredDependencies2(outputMeta, config) {
 function createDuplicateTaskIdOutputErrorMessage(duplicateTaskIds, taskResources) {
   const duplicateTable = duplicateTaskIds.map((id) => {
     const tasks = taskResources.filter((task) => task.id === id);
-    return `id "${chalkPurple(id)}" was found in:
-${tasks.map((task) => `${task.filePath} -> ${task.exportName}`).join("\n")}`;
-  }).join("\n\n");
-  return `Duplicate task ids detected:
-
-${duplicateTable}
+    return `
 
-`;
+${chalkTask(id)} was found in:${tasks.map((task) => `
+${task.filePath} -> ${task.exportName}`).join("")}`;
+  }).join("");
+  return `Duplicate ${chalkTask("task id")} detected:${duplicateTable}`;
 }
-function gatherProcessEnv() {
+async function gatherProcessEnv() {
   const env = {
     NODE_ENV: process.env.NODE_ENV ?? "development",
     PATH: process.env.PATH,
@@ -4970,31 +6071,54 @@ function gatherProcessEnv() {
     NVM_BIN: process.env.NVM_BIN,
     LANG: process.env.LANG,
     TERM: process.env.TERM,
-    NODE_PATH: process.env.NODE_PATH,
+    NODE_PATH: await amendNodePathWithPnpmNodeModules(process.env.NODE_PATH),
     HOME: process.env.HOME,
     BUN_INSTALL: process.env.BUN_INSTALL
   };
   return Object.fromEntries(Object.entries(env).filter(([key, value]) => value !== void 0));
 }
+async function amendNodePathWithPnpmNodeModules(nodePath) {
+  const pnpmModulesPath = await findPnpmNodeModulesPath();
+  if (!pnpmModulesPath) {
+    return nodePath;
+  }
+  if (nodePath) {
+    if (nodePath.includes(pnpmModulesPath)) {
+      return nodePath;
+    }
+    return `${nodePath}:${pnpmModulesPath}`;
+  }
+  return pnpmModulesPath;
+}
+async function findPnpmNodeModulesPath() {
+  return await findUp3(
+    async (directory) => {
+      const pnpmModules = join7(directory, "node_modules", ".pnpm", "node_modules");
+      const hasPnpmNodeModules = await pathExists2(pnpmModules);
+      if (hasPnpmNodeModules) {
+        return pnpmModules;
+      }
+    },
+    { type: "directory" }
+  );
+}
 
 // src/commands/init.ts
-import { intro as intro4, isCancel, log as log3, outro as outro4, select as select2, spinner as spinner5, text } from "@clack/prompts";
+import { intro as intro5, isCancel as isCancel2, log as log6, outro as outro6, select as select2, text } from "@clack/prompts";
 import { context as context3, trace as trace3 } from "@opentelemetry/api";
-import {
-  flattenAttributes as flattenAttributes3,
-  recordSpanException as recordSpanException5
-} from "@trigger.dev/core/v3";
+import { flattenAttributes as flattenAttributes3 } from "@trigger.dev/core/v3";
+import { recordSpanException as recordSpanException5 } from "@trigger.dev/core/v3/workers";
 import chalk5 from "chalk";
 import { execa as execa3 } from "execa";
 import { applyEdits, modify } from "jsonc-parser";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join6, relative as relative3, resolve as resolve3 } from "node:path";
-import terminalLink3 from "terminal-link";
+import { join as join8, relative as relative4, resolve as resolve4 } from "node:path";
+import terminalLink4 from "terminal-link";
 import { z as z6 } from "zod";
 
 // src/utilities/createFileFromTemplate.ts
 import fs8 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 async function createFileFromTemplate(params) {
   let template = await readFile(params.templatePath);
   if (await pathExists(params.outputPath) && !params.override) {
@@ -5005,7 +6129,7 @@ async function createFileFromTemplate(params) {
   }
   try {
     const output = replaceAll(template, params.replacements);
-    const directoryName = path5.dirname(params.outputPath);
+    const directoryName = path6.dirname(params.outputPath);
     await fs8.mkdir(directoryName, { recursive: true });
     await fs8.writeFile(params.outputPath, output);
     return {
@@ -5033,51 +6157,6 @@ function replaceAll(input, replacements) {
   return output;
 }
 
-// src/utilities/getUserPackageManager.ts
-import pathModule2 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(pathModule2.join(path6, name));
-    if (exists) {
-      return pm;
-    }
-  }
-  throw new Error("Could not detect package manager from artifacts");
-}
-
-// src/utilities/resolveInternalFilePath.ts
-import { resolve as importResolve3 } from "import-meta-resolve";
-function resolveInternalFilePath(filePath) {
-  return new URL(importResolve3(filePath, import.meta.url)).href.replace("file://", "");
-}
-
 // src/commands/init.ts
 var InitCommandOptions = CommonCommandOptions.extend({
   projectRef: z6.string().optional(),
@@ -5095,10 +6174,10 @@ function configureInitCommand(program2) {
       "The version of the @trigger.dev/sdk package to install",
       "beta"
     ).option("--skip-package-install", "Skip installing the @trigger.dev/sdk package").option("--override-config", "Override the existing config file if it exists")
-  ).action(async (path6, options) => {
+  ).action(async (path7, options) => {
     await handleTelemetry(async () => {
       await printStandloneInitialBanner(true);
-      await initCommand(path6, options);
+      await initCommand(path7, options);
     });
   });
 }
@@ -5109,7 +6188,7 @@ async function initCommand(dir, options) {
 }
 async function _initCommand(dir, options) {
   const span = trace3.getSpan(context3.active());
-  intro4("Initializing project");
+  intro5("Initializing project");
   const authorization = await login({
     embedded: true,
     defaultApiUrl: options.apiUrl,
@@ -5133,7 +6212,7 @@ async function _initCommand(dir, options) {
   if (!options.overrideConfig) {
     try {
       const result = await readConfig(dir);
-      outro4(
+      outro6(
         result.status === "file" ? `Project already initialized: Found config file at ${result.path}. Pass --override-config to override` : "Project already initialized"
       );
       return;
@@ -5150,55 +6229,56 @@ async function _initCommand(dir, options) {
     ...flattenAttributes3(selectedProject, "cli.project")
   });
   logger.debug("Selected project", selectedProject);
-  log3.step(`Configuring project "${selectedProject.name}" (${selectedProject.externalRef})`);
+  log6.step(`Configuring project "${selectedProject.name}" (${selectedProject.externalRef})`);
   if (!options.skipPackageInstall) {
     await installPackages2(dir, options);
   } else {
-    log3.info("Skipping package installation");
+    log6.info("Skipping package installation");
   }
   const triggerDir = await createTriggerDir(dir, options);
   await writeConfigFile(dir, selectedProject, options, triggerDir);
   await addConfigFileToTsConfig(dir, options);
   await gitIgnoreDotTriggerDir(dir, options);
-  const projectDashboard = terminalLink3(
+  const projectDashboard = terminalLink4(
     "project dashboard",
     `${authorization.dashboardUrl}/projects/v3/${selectedProject.externalRef}`
   );
-  log3.success("Successfully initialized project for Trigger.dev v3 \u{1FAE1}");
-  log3.info("Next steps:");
-  log3.info(
+  log6.success("Successfully initialized project for Trigger.dev v3 \u{1FAE1}");
+  log6.info("Next steps:");
+  log6.info(
     `   1. To start developing, run ${chalk5.green(
       `npx trigger.dev@${options.tag} dev`
     )} in your project directory`
   );
-  log3.info(`   2. Visit your ${projectDashboard} to view your newly created tasks.`);
-  log3.info(
-    `   3. Head over to our ${terminalLink3(
+  log6.info(`   2. Visit your ${projectDashboard} to view your newly created tasks.`);
+  log6.info(
+    `   3. Head over to our ${terminalLink4(
       "v3 docs",
       "https://trigger.dev/docs/v3"
     )} to learn more.`
   );
-  log3.info(
-    `   4. Need help? Join our ${terminalLink3(
+  log6.info(
+    `   4. Need help? Join our ${terminalLink4(
       "Discord community",
       "https://trigger.dev/discord"
     )} or email us at ${chalk5.cyan("help@trigger.dev")}`
   );
-  outro4(`Project initialized successfully. Happy coding!`);
+  outro6(`Project initialized successfully. Happy coding!`);
 }
 async function createTriggerDir(dir, options) {
   return await tracer.startActiveSpan("createTriggerDir", async (span) => {
     try {
-      const defaultValue = `${dir}/src/trigger`;
+      const defaultValue = join8(dir, "src", "trigger");
       const location = await text({
         message: "Where would you like to create the Trigger.dev directory?",
         defaultValue,
         placeholder: defaultValue
       });
-      if (isCancel(location)) {
+      if (isCancel2(location)) {
         throw new OutroCommandError();
       }
-      const triggerDir = resolve3(process.cwd(), location);
+      const triggerDir = resolve4(process.cwd(), location);
+      logger.debug({ triggerDir });
       span.setAttributes({
         "cli.triggerDir": triggerDir
       });
@@ -5216,7 +6296,7 @@ async function createTriggerDir(dir, options) {
           }
         ]
       });
-      if (isCancel(exampleSelection)) {
+      if (isCancel2(exampleSelection)) {
         throw new OutroCommandError();
       }
       const example = exampleSelection;
@@ -5224,20 +6304,20 @@ async function createTriggerDir(dir, options) {
         "cli.example": example
       });
       if (example === "none") {
-        await createFile(join6(triggerDir, ".gitkeep"), "");
-        log3.step(`Created directory at ${location}`);
+        await createFile(join8(triggerDir, ".gitkeep"), "");
+        log6.step(`Created directory at ${location}`);
         span.end();
         return { location, isCustomValue: location !== defaultValue };
       }
-      const exampleFile = resolveInternalFilePath(`./templates/examples/${example}.ts.template`);
-      const outputPath = join6(triggerDir, "example.ts");
+      const templatePath = join8(cliRootPath(), "templates", "examples", `${example}.ts.template`);
+      const outputPath = join8(triggerDir, "example.ts");
       await createFileFromTemplate({
-        templatePath: exampleFile,
+        templatePath,
         outputPath,
         replacements: {}
       });
-      const relativeOutputPath = relative3(process.cwd(), outputPath);
-      log3.step(`Created example file at ${relativeOutputPath}`);
+      const relativeOutputPath = relative4(process.cwd(), outputPath);
+      log6.step(`Created example file at ${relativeOutputPath}`);
       span.end();
       return { location, isCustomValue: location !== defaultValue };
     } catch (e) {
@@ -5252,15 +6332,15 @@ async function createTriggerDir(dir, options) {
 async function gitIgnoreDotTriggerDir(dir, options) {
   return await tracer.startActiveSpan("gitIgnoreDotTriggerDir", async (span) => {
     try {
-      const projectDir = resolve3(process.cwd(), dir);
-      const gitIgnorePath = join6(projectDir, ".gitignore");
+      const projectDir = resolve4(process.cwd(), dir);
+      const gitIgnorePath = join8(projectDir, ".gitignore");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.gitIgnorePath": gitIgnorePath
       });
       if (!await pathExists(gitIgnorePath)) {
         await createFile(gitIgnorePath, ".trigger");
-        log3.step(`Added .trigger to .gitignore`);
+        log6.step(`Added .trigger to .gitignore`);
         span.end();
         return;
       }
@@ -5272,7 +6352,7 @@ async function gitIgnoreDotTriggerDir(dir, options) {
       const newGitIgnoreContent = `${gitIgnoreContent}
 .trigger`;
       await writeFile3(gitIgnorePath, newGitIgnoreContent, "utf-8");
-      log3.step(`Added .trigger to .gitignore`);
+      log6.step(`Added .trigger to .gitignore`);
       span.end();
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
@@ -5286,8 +6366,8 @@ async function gitIgnoreDotTriggerDir(dir, options) {
 async function addConfigFileToTsConfig(dir, options) {
   return await tracer.startActiveSpan("createTriggerDir", async (span) => {
     try {
-      const projectDir = resolve3(process.cwd(), dir);
-      const tsconfigPath = join6(projectDir, "tsconfig.json");
+      const projectDir = resolve4(process.cwd(), dir);
+      const tsconfigPath = join8(projectDir, "tsconfig.json");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.tsconfigPath": tsconfigPath
@@ -5305,7 +6385,7 @@ async function addConfigFileToTsConfig(dir, options) {
       const newTsconfigContent = applyEdits(tsconfigContent, edits);
       logger.debug("new tsconfig.json content", { newTsconfigContent });
       await writeFile3(tsconfigPath, newTsconfigContent, "utf-8");
-      log3.step(`Added trigger.config.ts to tsconfig.json`);
+      log6.step(`Added trigger.config.ts to tsconfig.json`);
       span.end();
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
@@ -5318,9 +6398,9 @@ async function addConfigFileToTsConfig(dir, options) {
 }
 async function installPackages2(dir, options) {
   return await tracer.startActiveSpan("installPackages", async (span) => {
-    const installSpinner = spinner5();
+    const installSpinner = spinner();
     try {
-      const projectDir = resolve3(process.cwd(), dir);
+      const projectDir = resolve4(process.cwd(), dir);
       const pkgManager = await getUserPackageManager(projectDir);
       span.setAttributes({
         "cli.projectDir": projectDir,
@@ -5370,11 +6450,11 @@ async function installPackages2(dir, options) {
 async function writeConfigFile(dir, project, options, triggerDir) {
   return await tracer.startActiveSpan("writeConfigFile", async (span) => {
     try {
-      const spnnr = spinner5();
+      const spnnr = spinner();
       spnnr.start("Creating config file");
-      const projectDir = resolve3(process.cwd(), dir);
-      const templatePath = resolveInternalFilePath("./templates/trigger.config.ts.template");
-      const outputPath = join6(projectDir, "trigger.config.ts");
+      const projectDir = resolve4(process.cwd(), dir);
+      const templatePath = join8(cliRootPath(), "templates", "trigger.config.ts.template");
+      const outputPath = join8(projectDir, "trigger.config.ts");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.templatePath": templatePath,
@@ -5390,7 +6470,7 @@ async function writeConfigFile(dir, project, options, triggerDir) {
         outputPath,
         override: options.overrideConfig
       });
-      const relativePathToOutput = relative3(process.cwd(), outputPath);
+      const relativePathToOutput = relative4(process.cwd(), outputPath);
       spnnr.stop(
         result.success ? `Config file created at ${relativePathToOutput}` : `Failed to create config file: ${result.error}`
       );
@@ -5414,7 +6494,7 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
       if (projectRef) {
         const projectResponse = await apiClient2.getProject(projectRef);
         if (!projectResponse.success) {
-          log3.error(
+          log6.error(
             `--project-ref ${projectRef} is not a valid project ref. Request to fetch data resulted in: ${projectResponse.error}`
           );
           throw new SkipCommandError(projectResponse.error);
@@ -5430,11 +6510,11 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
         throw new Error(`Failed to get projects: ${projectsResponse.error}`);
       }
       if (projectsResponse.data.length === 0) {
-        const newProjectLink = terminalLink3(
+        const newProjectLink = terminalLink4(
           "Create new project",
           `${dashboardUrl}/projects/new?version=v3`
         );
-        outro4(`You don't have any projects yet. ${newProjectLink}`);
+        outro6(`You don't have any projects yet. ${newProjectLink}`);
         throw new SkipCommandError();
       }
       const selectedProject = await select2({
@@ -5445,7 +6525,7 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
           hint: project.organization.title
         }))
       });
-      if (isCancel(selectedProject)) {
+      if (isCancel2(selectedProject)) {
         throw new OutroCommandError();
       }
       const projectData = projectsResponse.data.find(
@@ -5472,12 +6552,14 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
 // src/commands/logout.ts
 var LogoutCommandOptions = CommonCommandOptions;
 function configureLogoutCommand(program2) {
-  return commonOptions(program2.command("logout").description("Logout of Trigger.dev")).action(async (options) => {
-    await handleTelemetry(async () => {
-      await printInitialBanner(false);
-      await logoutCommand(options);
-    });
-  });
+  return commonOptions(program2.command("logout").description("Logout of Trigger.dev")).action(
+    async (options) => {
+      await handleTelemetry(async () => {
+        await printInitialBanner(false);
+        await logoutCommand(options);
+      });
+    }
+  );
 }
 async function logoutCommand(options) {
   return await wrapCommandAction("logoutCommand", LogoutCommandOptions, options, async (opts) => {
@@ -5487,11 +6569,46 @@ async function logoutCommand(options) {
 async function logout(options) {
   const config = readAuthConfigProfile(options.profile);
   if (!config?.accessToken) {
-    logger.info(`You are already logged out [${options.profile ?? "default"}]`);
+    logger.info(`You are already logged out [${options.profile}]`);
+    return;
+  }
+  deleteAuthConfigProfile(options.profile);
+  logger.info(`Logged out of Trigger.dev [${options.profile}]`);
+}
+
+// src/commands/list-profiles.ts
+import { log as log7, outro as outro7 } from "@clack/prompts";
+var ListProfilesOptions = CommonCommandOptions;
+function configureListProfilesCommand(program2) {
+  return program2.command("list-profiles").description("List all of your CLI profiles").option(
+    "-l, --log-level <level>",
+    "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
+    "log"
+  ).option("--skip-telemetry", "Opt-out of sending telemetry").action(async (options) => {
+    await handleTelemetry(async () => {
+      await printInitialBanner(true);
+      await listProfilesCommand(options);
+    });
+  });
+}
+async function listProfilesCommand(options) {
+  return await wrapCommandAction("listProfiles", ListProfilesOptions, options, async (opts) => {
+    return await listProfiles(opts);
+  });
+}
+async function listProfiles(options) {
+  const authConfig = readAuthConfigFile();
+  if (!authConfig) {
+    logger.info("No profiles found");
     return;
   }
-  writeAuthConfigProfile({ ...config, accessToken: void 0, apiUrl: void 0 }, options.profile);
-  logger.info(`Logged out of Trigger.dev [${options.profile ?? "default"}]`);
+  const profiles = Object.keys(authConfig);
+  log7.message("Profiles:");
+  for (const profile of profiles) {
+    const profileConfig = authConfig[profile];
+    log7.info(`${profile}${profileConfig?.apiUrl ? ` - ${chalkGrey(profileConfig.apiUrl)}` : ""}`);
+  }
+  outro7("Retrieve account info by running whoami --profile <profile>");
 }
 
 // src/cli/index.ts
@@ -5503,6 +6620,8 @@ configureDevCommand(program);
 configureDeployCommand(program);
 configureWhoamiCommand(program);
 configureLogoutCommand(program);
+configureListProfilesCommand(program);
+configureUpdateCommand(program);
 
 // src/index.ts
 var main = async () => {