trigger.dev 0.0.0-prerelease-20240418145424 → 0.0.0-v2-prerelease-20240524135558

package/dist/index.js

@@ -777,31 +777,31 @@ var require_retry2 = __commonJS({
 import { Command as Command2 } from "commander";
 
 // src/commands/deploy.ts
-import { intro as intro3, log as log3, outro as outro3 } 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 flattenAttributes3
 } from "@trigger.dev/core/v3";
-import chalk5 from "chalk";
+import { recordSpanException as recordSpanException5 } 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 { 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 join5, relative as relative3, posix } from "node:path";
+import { dirname, join as join6, posix, relative as relative3 } 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 = "0.0.0-prerelease-20240418145424";
+var version = "3.0.0-beta.33";
 var dependencies = {
+  "@anatine/esbuild-decorators": "^0.2.19",
   "@clack/prompts": "^0.7.0",
   "@depot/cli": "0.0.1-cli.2.55.0",
   "@opentelemetry/api": "^1.8.0",
@@ -816,7 +816,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:0.0.0-prerelease-20240418145424",
+  "@trigger.dev/core": "workspace:3.0.0-beta.33",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -826,7 +826,7 @@ var dependencies = {
   dotenv: "^16.4.4",
   esbuild: "^0.19.11",
   evt: "^2.4.13",
-  execa: "^8.0.0",
+  execa: "^9.1.0",
   "find-up": "^7.0.0",
   glob: "^10.3.10",
   "gradient-string": "^2.0.2",
@@ -837,7 +837,6 @@ var dependencies = {
   "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",
@@ -856,7 +855,8 @@ var dependencies = {
   url: "^0.11.1",
   ws: "^8.12.0",
   zod: "3.22.3",
-  "zod-validation-error": "^1.5.0"
+  "zod-validation-error": "^1.5.0",
+  typescript: "^5.4.0"
 };
 var package_default = {
   name: "trigger.dev",
@@ -948,7 +948,8 @@ import {
   InitializeDeploymentResponseBody,
   GetDeploymentResponseBody,
   GetProjectsResponseBody,
-  GetProjectResponseBody
+  GetProjectResponseBody,
+  EnvironmentVariableResponseBody
 } from "@trigger.dev/core/v3";
 var CliApiClient = class {
   constructor(apiURL, accessToken) {
@@ -1052,6 +1053,23 @@ var CliApiClient = class {
       }
     );
   }
+  async importEnvVars(projectRef, slug, params) {
+    if (!this.accessToken) {
+      throw new Error("importEnvVars: No access token");
+    }
+    return zodfetch(
+      EnvironmentVariableResponseBody,
+      `${this.apiURL}/api/v1/projects/${projectRef}/envvars/${slug}/import`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      }
+    );
+  }
   async initializeDeployment(body) {
     if (!this.accessToken) {
       throw new Error("initializeDeployment: No access token");
@@ -1141,7 +1159,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
@@ -1151,6 +1170,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;
@@ -1162,7 +1185,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({
@@ -1179,10 +1203,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);
@@ -1195,7 +1218,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
@@ -1318,6 +1341,7 @@ var logger = new Logger();
 import { outro } from "@clack/prompts";
 
 // src/utilities/cliOutput.ts
+import { log } from "@clack/prompts";
 import chalk2 from "chalk";
 var green = "#4FFF54";
 var purple = "#735BF3";
@@ -1366,6 +1390,30 @@ function prettyPrintDate(date = /* @__PURE__ */ new 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({
@@ -1474,6 +1522,9 @@ async function createFile(path7, contents) {
 async function pathExists(path7) {
   return fsSync.existsSync(path7);
 }
+async function removeFile(path7) {
+  await fsModule.unlink(path7);
+}
 async function readFile(path7) {
   return await fsModule.readFile(path7, "utf8");
 }
@@ -1481,8 +1532,8 @@ async function readJSONFile(path7) {
   const fileContents = await fsModule.readFile(path7, "utf8");
   return JSON.parse(fileContents);
 }
-async function writeJSONFile(path7, json) {
-  await writeFile(path7, 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(path7) {
   const fileContents = fsSync.readFileSync(path7, "utf8");
@@ -1513,14 +1564,23 @@ 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;
+    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 importName = filePath.replace(/\..+$/, "").replace(/[^a-zA-Z0-9_$]/g, "_");
       const importPath = filePath.replace(/\\/g, "/");
@@ -1540,9 +1600,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);
     }
@@ -1553,6 +1616,7 @@ async function getTriggerDirectories(dirPath) {
 
 // src/utilities/configFiles.ts
 import { build } from "esbuild";
+import { esbuildDecorators } from "@anatine/esbuild-decorators";
 function getGlobalConfigFolderPath() {
   const configDir = mod_esm_default("trigger").config();
   return configDir;
@@ -1616,16 +1680,25 @@ 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);
   if (!configPath) {
     if (options?.projectRef) {
-      const rawConfig2 = await normalizeConfig({ project: options.projectRef });
-      const config2 = Config.parse(rawConfig2);
+      const rawConfig = await normalizeConfig({ project: options.projectRef });
+      const config = Config.parse(rawConfig);
       return {
         status: "in-memory",
-        config: await resolveConfig(absoluteDir, config2)
+        config: await resolveConfig(absoluteDir, config)
       };
     } else {
       throw new Error(`Config file not found in ${absoluteDir} or any parent directory.`);
@@ -1649,25 +1722,49 @@ async function readConfig(dir, options) {
     platform: "node",
     target: ["es2018", "node18"],
     outfile: builtConfigFilePath,
-    logLevel: "silent"
+    logLevel: "silent",
+    plugins: [
+      esbuildDecorators({
+        cwd: absoluteDir,
+        tsx: false,
+        force: false
+      }),
+      {
+        name: "native-node-modules",
+        setup(build3) {
+          const opts = build3.initialOptions;
+          opts.loader = opts.loader || {};
+          opts.loader[".node"] = "copy";
+        }
+      }
+    ]
   });
-  const userConfigModule = await import(builtConfigFileHref);
-  const rawConfig = await normalizeConfig(
-    userConfigModule?.config,
-    options?.projectRef ? { project: options?.projectRef } : void 0
-  );
-  const config = Config.parse(rawConfig);
-  return {
-    status: "file",
-    config: await resolveConfig(absoluteDir, config),
-    path: configPath
-  };
+  try {
+    const userConfigModule = await import(builtConfigFileHref);
+    const rawConfig = await normalizeConfig(
+      userConfigModule?.config,
+      options?.projectRef ? { project: options?.projectRef } : void 0
+    );
+    const config = Config.parse(rawConfig);
+    return {
+      status: "file",
+      config: await resolveConfig(absoluteDir, config),
+      path: configPath,
+      module: userConfigModule
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      error
+    };
+  }
 }
 async function resolveConfig(path7, config) {
   if (!config.triggerDirectories) {
     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;
   }
@@ -1675,7 +1772,7 @@ async function resolveConfig(path7, config) {
     config.projectDir = path7;
   }
   if (!config.tsconfigPath) {
-    config.tsconfigPath = await getConfigPath(path7, "tsconfig.json");
+    config.tsconfigPath = await findFilePath(path7, "tsconfig.json");
   }
   return config;
 }
@@ -1701,29 +1798,29 @@ function getVersion() {
 }
 
 // src/utilities/windows.ts
-import { log, spinner as clackSpinner } from "@clack/prompts";
+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) => {
-    log.step(msg ?? "");
+    log2.step(msg ?? "");
   },
   stop: (msg, code) => {
-    log.message(msg ?? "");
+    log2.message(msg ?? "");
   },
   message: (msg) => {
-    log.message(msg ?? "");
+    log2.message(msg ?? "");
   }
 });
 var spinner = () => isWindows ? ballmerSpinner() : clackSpinner();
 
 // src/utilities/initialBanner.ts
 async function printInitialBanner(performUpdateCheck = true) {
-  const packageVersion = getVersion();
+  const cliVersion = getVersion();
   const text3 = `
-${logo()} ${chalkGrey(`(${packageVersion})`)}
+${logo()} ${chalkGrey(`(${cliVersion})`)}
 `;
   logger.info(text3);
   let maybeNewVersion;
@@ -1733,7 +1830,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(
@@ -1748,18 +1845,26 @@ After installation, run Trigger.dev with \`npx trigger.dev\`.`
   }
 }
 async function printStandloneInitialBanner(performUpdateCheck = true) {
-  const packageVersion = getVersion();
-  logger.log(`
-${logo()} ${chalkGrey("(v3 Developer Preview)")}`);
+  const cliVersion = getVersion();
   if (performUpdateCheck) {
     const maybeNewVersion = await updateCheck();
     if (maybeNewVersion !== void 0) {
-      logger.log(`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(`${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"
@@ -1771,7 +1876,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) {
   }
@@ -1809,14 +1914,27 @@ function stripWorkspaceFromVersion(version2) {
   return version2.replace(/^workspace:/, "");
 }
 function parsePackageName(packageSpecifier) {
-  const parts = packageSpecifier.split("@");
-  if (parts.length === 1 && typeof parts[0] === "string") {
-    return { name: parts[0] };
+  let name;
+  let version2;
+  if (packageSpecifier.startsWith("@")) {
+    const atIndex = packageSpecifier.indexOf("@", 1);
+    if (atIndex !== -1) {
+      name = packageSpecifier.slice(0, atIndex);
+      version2 = packageSpecifier.slice(atIndex + 1);
+    } else {
+      name = packageSpecifier;
+    }
+  } else {
+    const [packageName, packageVersion] = packageSpecifier.split("@");
+    if (typeof packageName === "string") {
+      name = packageName;
+    }
+    version2 = packageVersion;
   }
-  if (parts.length === 2 && typeof parts[0] === "string" && typeof parts[1] === "string") {
-    return { name: parts[0], version: parts[1] };
+  if (!name) {
+    return { name: packageSpecifier };
   }
-  return { name: packageSpecifier };
+  return { name, version: version2 };
 }
 async function setPackageJsonDeps(path7, deps) {
   try {
@@ -1840,8 +1958,8 @@ async function setPackageJsonDeps(path7, deps) {
 }
 
 // src/commands/login.ts
-import { intro as intro2, log as log2, outro as outro2, select } 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";
@@ -2211,14 +2329,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve4(subprocess);
+        resolve6(subprocess);
       });
     });
   }
@@ -2335,7 +2453,7 @@ var decorateErrorWithCounts = (error, attemptNumber, options) => {
   return error;
 };
 async function pRetry(input, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     options = {
       onFailedAttempt() {
       },
@@ -2358,7 +2476,7 @@ async function pRetry(input, options) {
       try {
         const result = await input(attemptNumber);
         cleanUp();
-        resolve4(result);
+        resolve6(result);
       } catch (error) {
         try {
           if (!(error instanceof Error)) {
@@ -2388,10 +2506,10 @@ async function pRetry(input, options) {
 import { z as z3 } from "zod";
 
 // src/commands/whoami.ts
-import { intro, note } 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) => {
@@ -2473,9 +2591,16 @@ async function whoAmI(options, embedded = false) {
     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,
@@ -2571,10 +2696,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({
@@ -2592,7 +2725,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,
@@ -2633,11 +2766,11 @@ async function login(options) {
         }
       }
       if (opts.embedded) {
-        log2.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);
-      log2.step(
+      log3.step(
         `Please visit the following URL to login:
 ${chalkLink(authorizationCodeResult.url)}`
       );
@@ -2671,9 +2804,9 @@ ${chalkLink(authorizationCodeResult.url)}`
           throw new Error(whoAmIResult.error);
         }
         if (opts.embedded) {
-          log2.step("Logged in successfully");
+          log3.step("Logged in successfully");
         } else {
-          outro2("Logged in successfully");
+          outro3("Logged in successfully");
         }
         span.end();
         return {
@@ -2690,7 +2823,7 @@ ${chalkLink(authorizationCodeResult.url)}`
       } catch (e) {
         getPersonalAccessTokenSpinner.stop(`Failed to get access token`);
         if (e instanceof AbortError) {
-          log2.error(e.message);
+          log3.error(e.message);
         }
         recordSpanException3(span, e);
         span.end();
@@ -2740,7 +2873,7 @@ async function createAuthorizationCode(apiClient2) {
   return await tracer.startActiveSpan("createAuthorizationCode", async (span) => {
     try {
       const createAuthCodeSpinner = spinner();
-      createAuthCodeSpinner.start("Creating authorition code");
+      createAuthCodeSpinner.start("Creating authorization code");
       const authorizationCodeResult = await apiClient2.createAuthorizationCode();
       if (!authorizationCodeResult.success) {
         createAuthCodeSpinner.stop(
@@ -2764,18 +2897,45 @@ ${authorizationCodeResult.error}`
 }
 
 // src/commands/deploy.ts
+import { esbuildDecorators as esbuildDecorators2 } from "@anatine/esbuild-decorators";
 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 mockServerOnlyPlugin() {
+  return {
+    name: "trigger-mock-server-only",
+    setup(build3) {
+      build3.onResolve({ filter: /server-only/ }, (args) => {
+        if (args.path !== "server-only") {
+          return void 0;
+        }
+        logger.debug(`[trigger-mock-server-only] Bundling ${args.path}`, {
+          ...args
+        });
+        return {
+          path: args.path,
+          external: false,
+          namespace: "server-only-mock"
+        };
+      });
+      build3.onLoad({ filter: /server-only/, namespace: "server-only-mock" }, (args) => {
+        return {
+          contents: `export default true;`,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
 function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
   return {
     name: "trigger-bundle-core",
     setup(build3) {
       build3.onResolve({ filter: /.*/ }, (args) => {
-        if (args.path !== "@trigger.dev/core/v3") {
+        if (!args.path.startsWith("@trigger.dev/core/v3")) {
           return void 0;
         }
         const triggerSdkPath = __require.resolve("@trigger.dev/sdk/v3", { paths: [process.cwd()] });
@@ -2783,17 +2943,14 @@ function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
           ...args,
           triggerSdkPath
         });
-        const resolvedPath = __require.resolve("@trigger.dev/core/v3", {
+        const resolvedPath = __require.resolve(args.path, {
           paths: [triggerSdkPath]
         });
-        logger.debug(
-          `[${buildIdentifier}][trigger-bundle-core] Externalizing @trigger.dev/core/v3`,
-          {
-            ...args,
-            triggerSdkPath,
-            resolvedPath
-          }
-        );
+        logger.debug(`[${buildIdentifier}][trigger-bundle-core] Externalizing ${args.path}`, {
+          ...args,
+          triggerSdkPath,
+          resolvedPath
+        });
         return {
           path: resolvedPath,
           external: false
@@ -2862,7 +3019,7 @@ function bundleDependenciesPlugin(buildIdentifier, dependenciesToBundle, tsconfi
             return void 0;
           }
         }
-        logger.ignore(`[${buildIdentifier}] Externalizing ${args.path}`, {
+        logger.debug(`[${buildIdentifier}] Externalizing ${args.path}`, {
           ...args
         });
         return {
@@ -2954,6 +3111,20 @@ function getLoaderForFile(file) {
 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;
 }
@@ -3019,6 +3190,10 @@ ${chalkGrey("\u25CB")} Dynamically import the module in your code: ${chalkGrey(
 `
     );
   }
+  logger.log(
+    `${chalkGrey("\u25CB")} For more info see the ${terminalLink("relevant docs", docs.config.esm)}.
+`
+  );
 }
 function parseNpmInstallError(error) {
   if (typeof error === "string") {
@@ -3081,25 +3256,19 @@ ${chalkError("X Error:")} Failed to start. The following ${zodIssues.length ===
   }
 }
 
-// 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) {
@@ -3121,63 +3290,39 @@ function detectPackageManagerFromCurrentCommand() {
   }
 }
 async function detectPackageManagerFromArtifacts(path7) {
-  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 foundPath = await findUp2(name, { cwd: path7 });
-    if (typeof foundPath === "string") {
-      return pm;
-    }
+  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}`);
   }
-  throw new Error("Could not detect package manager from artifacts");
+}
+
+// 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"
-]);
+import { builtinModules } from "node:module";
+import { recordSpanException as recordSpanException4 } from "@trigger.dev/core/v3/otel";
+import { flattenAttributes as flattenAttributes2 } from "@trigger.dev/core/v3";
 var JavascriptProject = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
@@ -3192,36 +3337,107 @@ var JavascriptProject = class {
   }
   get scripts() {
     return {
-      postinstall: this.packageJson.scripts?.postinstall
+      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 resolveAll(packageNames, options) {
+    return tracer.startActiveSpan("JavascriptProject.resolveAll", async (span) => {
+      const externalPackages = packageNames.filter((packageName) => !isBuiltInModule(packageName));
+      const opts = { allowDev: false, ...options };
+      const command = await this.#getCommand();
+      span.setAttributes({
+        externalPackages,
+        packageManager: command.name
+      });
+      try {
+        const versions = await command.resolveDependencyVersions(externalPackages, {
+          cwd: this.projectPath
+        });
+        if (versions) {
+          logger.debug(`Resolved [${externalPackages.join(", ")}] version using ${command.name}`, {
+            versions
+          });
+          span.setAttributes({
+            ...flattenAttributes2(versions, "versions")
+          });
+        }
+        const missingPackages = externalPackages.filter((packageName) => !versions[packageName]);
+        const missingPackageVersions = {};
+        for (const packageName of missingPackages) {
+          const packageJsonVersion = this.packageJson.dependencies?.[packageName];
+          if (typeof packageJsonVersion === "string") {
+            logger.debug(`Resolved ${packageName} version using package.json`, {
+              packageJsonVersion
+            });
+            missingPackageVersions[packageName] = packageJsonVersion;
+          }
+          if (opts.allowDev) {
+            const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
+            if (typeof devPackageJsonVersion === "string") {
+              logger.debug(`Resolved ${packageName} version using devDependencies`, {
+                devPackageJsonVersion
+              });
+              missingPackageVersions[packageName] = devPackageJsonVersion;
+            }
+          }
+        }
+        span.setAttributes({
+          ...flattenAttributes2(missingPackageVersions, "missingPackageVersions"),
+          missingPackages
+        });
+        span.end();
+        return { ...versions, ...missingPackageVersions };
+      } catch (error) {
+        recordSpanException4(span, error);
+        span.end();
+        logger.debug(`Failed to resolve dependency versions using ${command.name}`, {
+          packageNames,
+          error
+        });
+        return {};
+      }
+    });
+  }
   async resolve(packageName, options) {
-    if (BuiltInModules.has(packageName)) {
+    if (isBuiltInModule(packageName)) {
       return void 0;
     }
-    if (!this._packageManager) {
-      this._packageManager = await getUserPackageManager(this.projectPath);
-    }
-    const packageManager = this._packageManager;
     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 = packageManager === "npm" ? new NPMCommands() : packageManager === "pnpm" ? new PNPMCommands() : new YarnCommands();
+    const command = await this.#getCommand();
     try {
       const version2 = await command.resolveDependencyVersion(packageName, {
         cwd: this.projectPath
       });
       if (version2) {
+        logger.debug(`Resolved ${packageName} version using ${command.name}`, { version: version2 });
         return version2;
       }
+      const packageJsonVersion = this.packageJson.dependencies?.[packageName];
+      if (typeof packageJsonVersion === "string") {
+        logger.debug(`Resolved ${packageName} version using package.json`, { packageJsonVersion });
+        return packageJsonVersion;
+      }
+      if (opts.allowDev) {
+        const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
+        if (typeof devPackageJsonVersion === "string") {
+          logger.debug(`Resolved ${packageName} version using devDependencies`, {
+            devPackageJsonVersion
+          });
+          return devPackageJsonVersion;
+        }
+      }
     } catch (error) {
       logger.debug(`Failed to resolve dependency version using ${command.name}`, {
         packageName,
@@ -3229,16 +3445,41 @@ var JavascriptProject = class {
       });
     }
   }
+  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 cmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-    const { stdout } = await $({ cwd: options.cwd })`${cmd} list ${packageName} -r --json`;
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageName} -r --json`;
     const result = JSON.parse(stdout);
-    logger.debug(`Resolving ${packageName} version using pnpm`, { result });
+    logger.debug(`Resolving ${packageName} version using ${this.name}`);
     for (const dep of result) {
       const dependency = dep.dependencies?.[packageName];
       if (dependency) {
@@ -3246,18 +3487,74 @@ var PNPMCommands = class {
       }
     }
   }
+  async resolveDependencyVersions(packageNames, options) {
+    const result = await this.#listDependencies(packageNames, options);
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
+    const results = {};
+    for (const dep of result) {
+      for (const packageName of packageNames) {
+        const dependency = dep.dependencies?.[packageName];
+        if (dependency) {
+          results[packageName] = dependency.version;
+        }
+      }
+    }
+    return results;
+  }
+  async #listDependencies(packageNames, options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} list ${packageNames} -r --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2.stderr
+      });
+    }
+    return JSON.parse(childProcess2.stdout);
+  }
 };
 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 cmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const { stdout } = await $({ cwd: options.cwd })`${cmd} list ${packageName} --json`;
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageName} --json`;
     const output = JSON.parse(stdout);
-    logger.debug(`Resolving ${packageName} version using npm`, { output });
+    logger.debug(`Resolving ${packageName} version using ${this.name}`, { output });
     return this.#recursivelySearchDependencies(output.dependencies, packageName);
   }
+  async resolveDependencyVersions(packageNames, options) {
+    const output = await this.#listDependencies(packageNames, options);
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`, { output });
+    const results = {};
+    for (const packageName of packageNames) {
+      const version2 = this.#recursivelySearchDependencies(output.dependencies, packageName);
+      if (version2) {
+        results[packageName] = version2;
+      }
+    }
+    return results;
+  }
+  async #listDependencies(packageNames, options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} list ${packageNames} --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2.stderr
+      });
+    }
+    return JSON.parse(childProcess2.stdout);
+  }
   #recursivelySearchDependencies(dependencies2, packageName) {
     for (const [name, dependency] of Object.entries(dependencies2)) {
       if (name === packageName) {
@@ -3276,11 +3573,17 @@ 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 cmd = process.platform === "win32" ? "yarn.cmd" : "yarn";
-    const { stdout } = await $({ cwd: options.cwd })`${cmd} info ${packageName} --json`;
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} info ${packageName} --json`;
     const lines = stdout.split("\n");
-    logger.debug(`Resolving ${packageName} version using yarn`, { lines });
+    logger.debug(`Resolving ${packageName} version using ${this.name}`);
     for (const line of lines) {
       const json = JSON.parse(line);
       if (json.value === packageName) {
@@ -3288,22 +3591,318 @@ var YarnCommands = class {
       }
     }
   }
-};
-
-// 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;
+  async resolveDependencyVersions(packageNames, options) {
+    const stdout = await this.#listDependencies(packageNames, options);
+    const lines = stdout.split("\n");
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
+    const results = {};
+    for (const line of lines) {
+      const json = JSON.parse(line);
+      const packageName = this.#parseYarnValueIntoPackageName(json.value);
+      if (packageNames.includes(packageName)) {
+        results[packageName] = json.children.Version;
+      }
+    }
+    return results;
+  }
+  async #listDependencies(packageNames, options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} info ${packageNames} --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2.stderr
+      });
+    }
+    return childProcess2.stdout;
+  }
+  // The "value" when doing yarn info is formatted like this:
+  // "package-name@npm:version" or "package-name@workspace:version"
+  // This function will parse the value into just the package name.
+  // This correctly handles scoped packages as well e.g. @scope/package-name@npm:version
+  #parseYarnValueIntoPackageName(value) {
+    const parts = value.split("@");
+    if (parts.length === 3) {
+      return parts[1];
+    }
+    return parts[0];
+  }
+};
+function isBuiltInModule(module) {
+  if (module.startsWith("node:")) {
+    return true;
+  }
+  return builtinModules.includes(module);
+}
+
+// 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/utilities/safeJsonParse.ts
+function safeJsonParse(json) {
+  if (!json) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+
+// 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/utilities/resolveEnvVars.ts
+async function callResolveEnvVars(configModule, env, environment, projectRef) {
+  if (configModule && configModule.resolveEnvVars && typeof configModule.resolveEnvVars === "function") {
+    let resolvedEnvVars2 = {};
+    try {
+      let result = await configModule.resolveEnvVars({
+        projectRef,
+        environment,
+        env
+      });
+      if (!result) {
+        return;
+      }
+      result = await result;
+      if (typeof result === "object" && result !== null && "variables" in result) {
+        const variables = result.variables;
+        if (Array.isArray(variables)) {
+          for (const item of variables) {
+            if (typeof item === "object" && item !== null && "name" in item && "value" in item && typeof item.name === "string" && typeof item.value === "string") {
+              resolvedEnvVars2[item.name] = item.value;
+            }
+          }
+        } else if (typeof variables === "object") {
+          for (const [key, value] of Object.entries(variables)) {
+            if (typeof key === "string" && typeof value === "string") {
+              resolvedEnvVars2[key] = value;
+            }
+          }
+        }
+      }
+      return {
+        variables: resolvedEnvVars2,
+        override: result.override
+      };
+    } catch (error) {
+      logger.error(error);
+    }
+  }
 }
 
 // src/commands/deploy.ts
 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"),
@@ -3313,7 +3912,10 @@ 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),
+  noCache: z4.boolean().default(false)
 });
 function configureDeployCommand(program2) {
   return commonOptions(
@@ -3321,10 +3923,7 @@ 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. This will override the project specified in the config file."
     )
@@ -3333,6 +3932,11 @@ function configureDeployCommand(program2) {
       "--self-hosted",
       "Build and load the image using your local Docker. Use the --registry option to specify the registry to push the image to when using --self-hosted, or just use --push-image to push to the default registry."
     ).hideHelp()
+  ).addOption(
+    new CommandOption(
+      "--no-cache",
+      "Do not use the cache when building the image. This will slow down the build process but can be useful if you are experiencing issues with the cache."
+    ).hideHelp()
   ).addOption(
     new CommandOption(
       "--push",
@@ -3348,6 +3952,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(
@@ -3360,6 +3969,11 @@ function configureDeployCommand(program2) {
       "--output-metafile <path>",
       "If provided, will save the esbuild metafile for the build to the specified path"
     ).hideHelp()
+  ).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);
@@ -3374,7 +3988,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,
@@ -3398,6 +4015,11 @@ async function _deployCommand(dir, options) {
     configFile: options.config,
     projectRef: options.projectRef
   });
+  if (resolvedConfig.status === "error") {
+    logger.error("Failed to read config:", resolvedConfig.error);
+    span && recordSpanException5(span, resolvedConfig.error);
+    throw new SkipLoggingError("Failed to read config");
+  }
   logger.debug("Resolved config", { resolvedConfig });
   span?.setAttributes({
     "resolvedConfig.status": resolvedConfig.status,
@@ -3406,7 +4028,7 @@ async function _deployCommand(dir, options) {
     "resolvedConfig.config.projectDir": resolvedConfig.config.projectDir,
     "resolvedConfig.config.triggerUrl": resolvedConfig.config.triggerUrl,
     "resolvedConfig.config.triggerDirectories": resolvedConfig.config.triggerDirectories,
-    ...flattenAttributes2(resolvedConfig.config.retries, "resolvedConfig.config.retries")
+    ...flattenAttributes3(resolvedConfig.config.retries, "resolvedConfig.config.retries")
   });
   const apiClient2 = new CliApiClient(authorization.auth.apiUrl, authorization.auth.accessToken);
   const deploymentEnv = await apiClient2.getProjectEnv({
@@ -3417,7 +4039,7 @@ async function _deployCommand(dir, options) {
     throw new Error(deploymentEnv.error);
   }
   const environmentClient = new CliApiClient(authorization.auth.apiUrl, deploymentEnv.data.apiKey);
-  log3.step(
+  log5.step(
     `Preparing to deploy "${deploymentEnv.data.name}" (${resolvedConfig.config.project}) to ${options.env}`
   );
   const compilation = await compileProject(
@@ -3426,15 +4048,7 @@ 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
-    );
-  }
+  await resolveEnvironmentVariables(resolvedConfig, environmentClient, options);
   const deploymentResponse = await environmentClient.initializeDeployment({
     contentHash: compilation.contentHash,
     userId: authorization.userId
@@ -3465,7 +4079,8 @@ async function _deployCommand(dir, options) {
         projectRef: resolvedConfig.config.project,
         buildPlatform: options.buildPlatform,
         pushImage: options.push,
-        selfHostedRegistry: !!options.registry
+        selfHostedRegistry: !!options.registry,
+        noCache: options.noCache
       });
     }
     if (!deploymentResponse.data.externalBuildData) {
@@ -3488,25 +4103,42 @@ async function _deployCommand(dir, options) {
         contentHash: deploymentResponse.data.contentHash,
         projectRef: resolvedConfig.config.project,
         loadImage: options.loadImage,
-        buildPlatform: options.buildPlatform
+        buildPlatform: options.buildPlatform,
+        noCache: options.noCache
       },
       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.`);
-    if (image.logs.trim() !== "") {
-      const logPath = join5(await createTempDir(), `build-${deploymentResponse.data.shortCode}.log`);
-      await writeFile2(logPath, image.logs);
-      logger.log(
-        `${chalkError("X Error:")} ${image.error}. Full build logs have been saved to ${logPath})`
-      );
-    } else {
-      logger.log(`${chalkError("X Error:")} ${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
@@ -3515,6 +4147,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(
@@ -3524,11 +4157,13 @@ async function _deployCommand(dir, options) {
   const startIndexingResponse = await environmentClient.startDeploymentIndexing(
     deploymentResponse.data.id,
     {
-      imageReference
+      imageReference,
+      selfHosted: options.selfHosted
     }
   );
   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(
@@ -3537,26 +4172,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}`
         );
       }
@@ -3571,6 +4213,7 @@ async function _deployCommand(dir, options) {
             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}`
               );
@@ -3585,6 +4228,7 @@ async function _deployCommand(dir, options) {
           deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
           logESMRequireError(parsedError, resolvedConfig);
         }
+        await preExitTasks();
         throw new SkipLoggingError(
           `Deployment encountered an error: ${finishedDeployment.errorData.name}`
         );
@@ -3592,62 +4236,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 = spinner();
-      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. "}${chalk5.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) => {
@@ -3677,7 +4391,7 @@ async function waitForDeploymentToFinish(deploymentId, client, timeoutInSeconds
         await setTimeout2(1e3);
       }
     } catch (error) {
-      recordSpanException4(span, error);
+      recordSpanException5(span, error);
       span.end();
       return error instanceof Error ? error.message : JSON.stringify(error);
     }
@@ -3704,6 +4418,7 @@ async function buildAndPushImage(options, updater) {
       "build",
       "-f",
       "Containerfile",
+      options.noCache ? "--no-cache" : void 0,
       "--platform",
       options.buildPlatform,
       "--provenance",
@@ -3769,7 +4484,7 @@ async function buildAndPushImage(options, updater) {
         digest
       };
     } catch (e) {
-      recordSpanException4(span, e);
+      recordSpanException5(span, e);
       span.end();
       return {
         ok: false,
@@ -3795,6 +4510,7 @@ async function buildAndPushSelfHostedImage(options) {
       "build",
       "-f",
       "Containerfile",
+      options.noCache ? "--no-cache" : void 0,
       "--platform",
       options.buildPlatform,
       "--build-arg",
@@ -3812,7 +4528,9 @@ async function buildAndPushSelfHostedImage(options) {
       "."
       // The build context
     ].filter(Boolean);
-    logger.debug(`docker ${buildArgs.join(" ")}`);
+    logger.debug(`docker ${buildArgs.join(" ")}`, {
+      cwd: options.cwd
+    });
     span.setAttribute("docker.command.build", `docker ${buildArgs.join(" ")}`);
     const buildProcess = execa2("docker", buildArgs, {
       cwd: options.cwd
@@ -3841,7 +4559,7 @@ async function buildAndPushSelfHostedImage(options) {
         "image.digest": digest
       });
     } catch (e) {
-      recordSpanException4(span, e);
+      recordSpanException5(span, e);
       span.end();
       return {
         ok: false,
@@ -3878,7 +4596,7 @@ async function buildAndPushSelfHostedImage(options) {
         }
         span.end();
       } catch (e) {
-        recordSpanException4(span, e);
+        recordSpanException5(span, e);
         span.end();
         return {
           ok: false,
@@ -3923,13 +4641,15 @@ async function compileProject(config, options, configPath) {
       compileSpinner.start(`Building project in ${config.projectDir}`);
       const taskFiles = await gatherTaskFiles(config);
       const workerFacade = readFileSync2(
-        join5(cliRootPath(), "workers", "prod", "worker-facade.js"),
+        join6(cliRootPath(), "workers", "prod", "worker-facade.js"),
         "utf-8"
       );
-      const workerSetupPath = join5(cliRootPath(), "workers", "dev", "worker-setup.js");
+      const workerSetupPath = join6(cliRootPath(), "workers", "prod", "worker-setup.js");
       let workerContents = workerFacade.replace("__TASKS__", createTaskFileImports(taskFiles)).replace(
         "__WORKER_SETUP__",
-        `import { tracingSDK } from "${escapeImportPath(workerSetupPath)}";`
+        `import { tracingSDK, otelTracer, otelLogger } from "${escapeImportPath(
+          workerSetupPath
+        )}";`
       );
       if (configPath) {
         logger.debug("Importing project config from", { configPath });
@@ -3963,17 +4683,26 @@ async function compileProject(config, options, configPath) {
         // This is needed to support opentelemetry instrumentation that uses module patching
         target: ["node18", "es2020"],
         outdir: "out",
+        banner: {
+          js: `process.on("uncaughtException", function(error, origin) { if (error instanceof Error) { process.send && process.send({ type: "EVENT", message: { type: "UNCAUGHT_EXCEPTION", payload: { error: { name: error.name, message: error.message, stack: error.stack }, origin }, version: "v1" } }); } else { process.send && process.send({ type: "EVENT", message: { type: "UNCAUGHT_EXCEPTION", payload: { error: { name: "Error", message: typeof error === "string" ? error : JSON.stringify(error) }, origin }, version: "v1" } }); } });`
+        },
         define: {
           TRIGGER_API_URL: `"${config.triggerUrl}"`,
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
+          mockServerOnlyPlugin(),
           bundleDependenciesPlugin(
             "workerFacade",
             config.dependenciesToBundle,
             config.tsconfigPath
           ),
-          workerSetupImportConfigPlugin(configPath)
+          workerSetupImportConfigPlugin(configPath),
+          esbuildDecorators2({
+            tsconfig: config.tsconfigPath,
+            tsx: true,
+            force: false
+          })
         ]
       });
       if (result.errors.length > 0) {
@@ -3986,10 +4715,10 @@ async function compileProject(config, options, configPath) {
         throw new Error("Build failed, aborting deployment");
       }
       if (options.outputMetafile) {
-        await writeJSONFile(join5(options.outputMetafile, "worker.json"), result.metafile);
+        await writeJSONFile(join6(options.outputMetafile, "worker.json"), result.metafile);
       }
       const entryPointContents = readFileSync2(
-        join5(cliRootPath(), "workers", "prod", "entry-point.js"),
+        join6(cliRootPath(), "workers", "prod", "entry-point.js"),
         "utf-8"
       );
       const entryPointResult = await build2({
@@ -4032,7 +4761,7 @@ async function compileProject(config, options, configPath) {
       }
       if (options.outputMetafile) {
         await writeJSONFile(
-          join5(options.outputMetafile, "entry-point.json"),
+          join6(options.outputMetafile, "entry-point.json"),
           entryPointResult.metafile
         );
       }
@@ -4043,31 +4772,32 @@ async function compileProject(config, options, configPath) {
       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 === join5(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 === join5(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 === join5(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(
-        join5(tempDir, "worker.js"),
+        join6(tempDir, "worker.js"),
         `${workerOutputFile.text}
 //# sourceMappingURL=worker.js.map`
       );
-      await writeFile2(join5(tempDir, "worker.js.map"), workerSourcemapFile.text);
-      await writeFile2(join5(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 javascriptProject = new JavascriptProject(config.projectDir);
-      const dependencies2 = await gatherRequiredDependencies(allImports, config, javascriptProject);
+      const dependencies2 = await resolveRequiredDependencies(allImports, config, javascriptProject);
+      logger.debug("gatherRequiredDependencies()", { dependencies: dependencies2 });
       const packageJsonContents = {
         name: "trigger-worker",
         version: "0.0.0",
@@ -4077,9 +4807,26 @@ async function compileProject(config, options, configPath) {
           ...javascriptProject.scripts
         }
       };
-      await writeJSONFile(join5(tempDir, "package.json"), packageJsonContents);
-      await copyAdditionalFiles(config, tempDir);
-      compileSpinner.stop("Project built successfully");
+      span.setAttributes({
+        ...flattenAttributes3(packageJsonContents, "packageJson.contents")
+      });
+      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,
@@ -4089,32 +4836,96 @@ async function compileProject(config, options, configPath) {
       if (!resolvingDependenciesResult) {
         throw new SkipLoggingError("Failed to resolve dependencies");
       }
-      const containerFilePath = join5(cliRootPath(), "Containerfile.prod");
-      await copyFile(containerFilePath, join5(tempDir, "Containerfile"));
+      const containerFilePath = join6(cliRootPath(), "Containerfile.prod");
+      let containerFileContents = readFileSync2(containerFilePath, "utf-8");
+      if (config.postInstall) {
+        containerFileContents = containerFileContents.replace(
+          "__POST_INSTALL__",
+          `RUN ${config.postInstall}`
+        );
+      } else {
+        containerFileContents = containerFileContents.replace("__POST_INSTALL__", "");
+      }
+      await writeFile2(join6(tempDir, "Containerfile"), containerFileContents);
       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);
+      recordSpanException5(span, e);
       span.end();
       throw e;
     }
   });
 }
+async function resolveEnvironmentVariables(config, apiClient2, options) {
+  if (config.status !== "file") {
+    return;
+  }
+  if (!config.module || typeof config.module.resolveEnvVars !== "function") {
+    return;
+  }
+  const projectConfig = config.config;
+  return await tracer.startActiveSpan("resolveEnvironmentVariables", async (span) => {
+    try {
+      const $spinner = spinner();
+      $spinner.start("Resolving environment variables");
+      let processEnv = {
+        ...process.env
+      };
+      const environmentVariables = await apiClient2.getEnvironmentVariables(projectConfig.project);
+      if (environmentVariables.success) {
+        processEnv = {
+          ...processEnv,
+          ...environmentVariables.data.variables
+        };
+      }
+      logger.debug("Existing environment variables", {
+        keys: Object.keys(processEnv)
+      });
+      const resolvedEnvVars2 = await callResolveEnvVars(
+        config.module,
+        processEnv,
+        options.env,
+        projectConfig.project
+      );
+      if (resolvedEnvVars2) {
+        const total = Object.keys(resolvedEnvVars2.variables).length;
+        logger.debug("Resolved env vars", {
+          keys: Object.keys(resolvedEnvVars2.variables)
+        });
+        if (total > 0) {
+          $spinner.message(
+            `Syncing ${total} environment variable${total > 1 ? "s" : ""} with the server`
+          );
+          const uploadResult = await apiClient2.importEnvVars(projectConfig.project, options.env, {
+            variables: resolvedEnvVars2.variables,
+            override: typeof resolvedEnvVars2.override === "boolean" ? resolvedEnvVars2.override : true
+          });
+          if (uploadResult.success) {
+            $spinner.stop(`${total} environment variable${total > 1 ? "s" : ""} synced`);
+          } else {
+            $spinner.stop("Failed to sync environment variables");
+            throw new Error(uploadResult.error);
+          }
+        } else {
+          $spinner.stop("No environment variables to sync");
+        }
+      }
+    } catch (e) {
+      recordSpanException5(span, e);
+      throw e;
+    } finally {
+      span.end();
+    }
+  });
+}
 async function resolveDependencies(projectDir, packageJsonContents, config, options) {
   return await tracer.startActiveSpan("resolveDependencies", async (span) => {
     const resolvingDepsSpinner = spinner();
@@ -4122,17 +4933,17 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
     const hasher = createHash("sha256");
     hasher.update(JSON.stringify(packageJsonContents));
     const digest = hasher.digest("hex").slice(0, 16);
-    const cacheDir = join5(config.projectDir, ".trigger", "cache");
-    const cachePath = join5(cacheDir, `${digest}.json`);
+    const cacheDir = join6(config.projectDir, ".trigger", "cache");
+    const cachePath = join6(cacheDir, `${digest}.json`);
     span.setAttributes({
       "packageJson.digest": digest,
       "cache.path": cachePath,
-      ...flattenAttributes2(packageJsonContents, "packageJson.contents")
+      ...flattenAttributes3(packageJsonContents, "packageJson.contents")
     });
     try {
       const cachedPackageLock = await readFile2(cachePath, "utf-8");
       logger.debug(`Using cached package-lock.json for ${digest}`);
-      await writeFile2(join5(projectDir, "package-lock.json"), cachedPackageLock);
+      await writeFile2(join6(projectDir, "package-lock.json"), cachedPackageLock);
       span.setAttributes({
         "cache.hit": true
       });
@@ -4151,20 +4962,39 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
       });
       logger.debug(`No cached package-lock.json found for ${digest}`);
       try {
-        await execa2("npm", ["install", "--package-lock-only", "--ignore-scripts", "--no-audit"], {
-          cwd: projectDir,
-          stdio: logger.loggerLevel === "debug" ? "inherit" : "pipe"
-        });
-        const packageLockContents = await readFile2(join5(projectDir, "package-lock.json"), "utf-8");
+        if (logger.loggerLevel === "debug") {
+          const childProcess2 = await execa2("npm", ["config", "list"], {
+            cwd: projectDir,
+            stdio: "inherit"
+          });
+          logger.debug("npm config list");
+          console.log(childProcess2.stdout);
+        }
+        await execa2(
+          "npm",
+          [
+            "install",
+            "--package-lock-only",
+            "--ignore-scripts",
+            "--no-audit",
+            "--legacy-peer-deps=false",
+            "--strict-peer-deps=false"
+          ],
+          {
+            cwd: projectDir,
+            stdio: logger.loggerLevel === "debug" ? "inherit" : "pipe"
+          }
+        );
+        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(join5(projectDir, "package-lock.json"), packageLockContents);
+        await writeFile2(join6(projectDir, "package-lock.json"), packageLockContents);
         span.end();
         resolvingDepsSpinner.stop("Dependencies resolved");
         return true;
       } catch (installError) {
-        recordSpanException4(span, installError);
+        recordSpanException5(span, installError);
         span.end();
         const parsedError = parseNpmInstallError(installError);
         if (typeof parsedError === "string") {
@@ -4211,8 +5041,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((resolve6, reject) => {
+          tscTypecheck.addListener("exit", (code) => code === 0 ? resolve6(code) : reject(code));
         });
       } catch (error) {
         typecheckSpinner.stop(
@@ -4230,64 +5060,100 @@ async function typecheckProject(config, options) {
       span.end();
       return true;
     } catch (e) {
-      recordSpanException4(span, e);
+      recordSpanException5(span, e);
       span.end();
       return false;
     }
   });
 }
-async function gatherRequiredDependencies(imports, config, project) {
-  const dependencies2 = {};
-  for (const file of imports) {
-    if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
-      continue;
-    }
-    const packageName = detectPackageNameFromImportPath(file.path);
-    if (dependencies2[packageName]) {
-      continue;
-    }
-    const externalDependencyVersion = await project.resolve(packageName);
-    if (externalDependencyVersion) {
-      dependencies2[packageName] = stripWorkspaceFromVersion(externalDependencyVersion);
-      continue;
-    }
-    const internalDependencyVersion = dependencies[packageName] ?? detectDependencyVersion(packageName);
-    if (internalDependencyVersion) {
-      dependencies2[packageName] = stripWorkspaceFromVersion(internalDependencyVersion);
-    }
-  }
-  if (config.additionalPackages) {
-    for (const packageName of config.additionalPackages) {
-      if (dependencies2[packageName]) {
+async function resolveRequiredDependencies(imports, config, project) {
+  return await tracer.startActiveSpan("resolveRequiredDependencies", async (span) => {
+    const resolvablePackageNames = /* @__PURE__ */ new Set();
+    for (const file of imports) {
+      if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
         continue;
       }
-      const packageParts = parsePackageName(packageName);
-      if (packageParts.version) {
-        dependencies2[packageParts.name] = packageParts.version;
+      const packageName = detectPackageNameFromImportPath(file.path);
+      if (!packageName) {
         continue;
-      } else {
-        const externalDependencyVersion = await project.resolve(packageParts.name, {
-          allowDev: true
-        });
-        if (externalDependencyVersion) {
-          dependencies2[packageParts.name] = externalDependencyVersion;
+      }
+      resolvablePackageNames.add(packageName);
+    }
+    span.setAttribute("resolvablePackageNames", Array.from(resolvablePackageNames));
+    const resolvedPackageVersions = await project.resolveAll(Array.from(resolvablePackageNames));
+    const missingPackages = Array.from(resolvablePackageNames).filter(
+      (packageName) => !resolvedPackageVersions[packageName]
+    );
+    span.setAttributes({
+      ...flattenAttributes3(resolvedPackageVersions, "resolvedPackageVersions")
+    });
+    span.setAttribute("missingPackages", missingPackages);
+    const dependencies2 = {};
+    for (const missingPackage of missingPackages) {
+      const internalDependencyVersion = dependencies[missingPackage] ?? detectDependencyVersion(missingPackage);
+      if (internalDependencyVersion) {
+        dependencies2[missingPackage] = stripWorkspaceFromVersion(internalDependencyVersion);
+      }
+    }
+    for (const [packageName, version2] of Object.entries(resolvedPackageVersions)) {
+      dependencies2[packageName] = version2;
+    }
+    if (config.additionalPackages) {
+      span.setAttribute("additionalPackages", config.additionalPackages);
+      for (const packageName of config.additionalPackages) {
+        if (dependencies2[packageName]) {
+          continue;
+        }
+        const packageParts = parsePackageName(packageName);
+        if (packageParts.version) {
+          dependencies2[packageParts.name] = packageParts.version;
           continue;
         } else {
-          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`
-          );
+          const externalDependencyVersion = await project.resolve(packageParts.name, {
+            allowDev: true
+          });
+          if (externalDependencyVersion) {
+            dependencies2[packageParts.name] = externalDependencyVersion;
+            continue;
+          } else {
+            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`
+            );
+          }
         }
       }
     }
-  }
-  return Object.fromEntries(Object.entries(dependencies2).sort(([a], [b]) => a.localeCompare(b)));
+    if (!dependencies2["@trigger.dev/sdk"]) {
+      logger.debug("Adding missing @trigger.dev/sdk dependency", {
+        version
+      });
+      span.setAttribute("addingMissingSDK", version);
+      dependencies2["@trigger.dev/sdk"] = version;
+    }
+    if (!dependencies2["@trigger.dev/core"]) {
+      logger.debug("Adding missing @trigger.dev/core dependency", {
+        version
+      });
+      span.setAttribute("addingMissingCore", version);
+      dependencies2["@trigger.dev/core"] = version;
+    }
+    const result = Object.fromEntries(
+      Object.entries(dependencies2).sort(([a], [b]) => a.localeCompare(b))
+    );
+    span.setAttributes({
+      ...flattenAttributes3(result, "dependencies")
+    });
+    span.end();
+    return result;
+  });
 }
 async function copyAdditionalFiles(config, tempDir) {
   const additionalFiles = config.additionalFiles ?? [];
+  const noMatches = [];
   if (additionalFiles.length === 0) {
-    return;
+    return { ok: true };
   }
   return await tracer.startActiveSpan(
     "copyAdditionalFiles",
@@ -4301,24 +5167,57 @@ 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 = join5(
-            tempDir,
-            relative3(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);
+        recordSpanException5(span, error);
         span.end();
         throw error;
       }
@@ -4327,7 +5226,7 @@ async function copyAdditionalFiles(config, tempDir) {
 }
 async function ensureLoggedIntoDockerRegistry(registryHost, auth) {
   const tmpDir = await createTempDir();
-  const dockerConfigPath = join5(tmpDir, "config.json");
+  const dockerConfigPath = join6(tmpDir, "config.json");
   await writeJSONFile(dockerConfigPath, {
     auths: {
       [registryHost]: {
@@ -4338,42 +5237,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 { 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 join6, normalize } 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";
@@ -4402,18 +5279,17 @@ var TaskMetadataParseError = class extends Error {
 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 resolve4 } from "node:path";
+import terminalLink3 from "terminal-link";
 var BackgroundWorkerCoordinator = class {
   constructor(baseURL) {
     this.baseURL = baseURL;
@@ -4498,7 +5374,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);
@@ -4585,6 +5461,7 @@ var BackgroundWorker = class {
   metadata;
   _taskRunProcesses = /* @__PURE__ */ new Map();
   _closed = false;
+  _fullEnv = {};
   close() {
     if (this._closed) {
       return;
@@ -4607,12 +5484,24 @@ var BackgroundWorker = class {
     }
     let resolved = false;
     const cwd = dirname2(this.path);
-    const fullEnv = {
+    this._fullEnv = {
       ...this.params.env,
-      ...this.#readEnvVars()
+      ...this.#readEnvVars(),
+      ...this.params.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
+    };
+    let resolvedEnvVars2 = {};
+    if (this.params.resolveEnvVariables) {
+      const resolvedEnv = await this.params.resolveEnvVariables(this._fullEnv, this);
+      if (resolvedEnv) {
+        resolvedEnvVars2 = resolvedEnv;
+      }
+    }
+    this._fullEnv = {
+      ...this._fullEnv,
+      ...resolvedEnvVars2
     };
-    logger.debug("Initializing worker", { path: this.path, cwd, fullEnv });
-    this.tasks = await new Promise((resolve4, reject) => {
+    logger.debug("Initializing worker", { path: this.path, cwd, fullEnv: this._fullEnv });
+    this.tasks = await new Promise((resolve6, reject) => {
       const child = fork(this.path, {
         stdio: [
           /*stdin*/
@@ -4624,7 +5513,7 @@ var BackgroundWorker = class {
           "ipc"
         ],
         cwd,
-        env: fullEnv
+        env: this._fullEnv
       });
       const timeout = setTimeout(() => {
         if (resolved) {
@@ -4639,7 +5528,7 @@ var BackgroundWorker = class {
         if (message.type === "TASKS_READY" && !resolved) {
           clearTimeout(timeout);
           resolved = true;
-          resolve4(message.payload.tasks);
+          resolve6(message.payload.tasks);
           child.kill();
         } else if (message.type === "UNCAUGHT_EXCEPTION") {
           clearTimeout(timeout);
@@ -4682,9 +5571,8 @@ var BackgroundWorker = class {
         payload.execution,
         this.path,
         {
-          ...this.params.env,
-          ...payload.environment ?? {},
-          ...this.#readEnvVars()
+          ...this._fullEnv,
+          ...payload.environment ?? {}
         },
         this.metadata,
         this.params
@@ -4774,7 +5662,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) => resolve4(process.cwd(), p))
     });
     process.env.TRIGGER_API_URL && (result.TRIGGER_API_URL = process.env.TRIGGER_API_URL);
     delete result.TRIGGER_API_URL;
@@ -4865,12 +5753,18 @@ var TaskRunProcess = class {
       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((resolve6, reject) => {
+      resolver = resolve6;
       rejecter = reject;
     });
     this._attemptStatuses.set(payload.execution.attempt.id, "PENDING");
@@ -4921,6 +5815,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;
       }
@@ -4983,6 +5878,7 @@ var TaskRunProcess = class {
   }
   #kill() {
     if (this._child && !this._child.killed) {
+      logger.debug(`[${this.execution.run.id}] killing task run process`);
       this._child?.kill();
     }
   }
@@ -5009,19 +5905,21 @@ function runtimeCheck(minimumMajor, minimumMinor) {
 
 // src/commands/dev.tsx
 import { findUp as findUp3, pathExists as pathExists2 } from "find-up";
+import { esbuildDecorators as esbuildDecorators3 } from "@anatine/esbuild-decorators";
 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(
       "-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")
+    ).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(path7, opts);
@@ -5063,29 +5961,37 @@ async function startDev(dir, options, authorization, dashboardUrl) {
       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,
       configFile: options.config
     });
     logger.debug("Initial config", { config });
-    async function getDevReactElement(configParam, authorization2, configPath) {
+    if (config.status === "error") {
+      logger.error("Failed to read config", config.error);
+      process.exit(1);
+    }
+    async function getDevReactElement(configParam, authorization2, configPath, configModule) {
       const accessToken = authorization2.accessToken;
       const apiUrl = authorization2.apiUrl;
       apiClient = new CliApiClient(apiUrl, accessToken);
       const devEnv = await apiClient.getProjectEnv({
-        projectRef: config.config.project,
+        projectRef: configParam.project,
         env: "dev"
       });
       if (!devEnv.success) {
         if (devEnv.error === "Project not found") {
           logger.error(
-            `Project not found: ${config.config.project}. Ensure you are using the correct project ref and CLI profile (use --profile). Currently using the "${options.profile}" profile, which points to ${authorization2.apiUrl}`
+            `Project not found: ${configParam.project}. Ensure you are using the correct project ref and CLI profile (use --profile). Currently using the "${options.profile}" profile, which points to ${authorization2.apiUrl}`
           );
         } else {
           logger.error(
-            `Failed to initialize dev environment: ${devEnv.error}. Using project ref ${config.config.project}`
+            `Failed to initialize dev environment: ${devEnv.error}. Using project ref ${configParam.project}`
           );
         }
         process.exit(1);
@@ -5102,7 +6008,8 @@ async function startDev(dir, options, authorization, dashboardUrl) {
           projectName: devEnv.data.name,
           debuggerOn: options.debugger,
           debugOtel: options.debugOtel,
-          configPath
+          configPath,
+          configModule
         }
       );
     }
@@ -5110,7 +6017,8 @@ async function startDev(dir, options, authorization, dashboardUrl) {
       await getDevReactElement(
         config.config,
         authorization,
-        config.status === "file" ? config.path : void 0
+        config.status === "file" ? config.path : void 0,
+        config.status === "file" ? config.module : void 0
       )
     );
     rerender = devReactElement.rerender;
@@ -5133,7 +6041,8 @@ function useDev({
   projectName,
   debuggerOn,
   debugOtel,
-  configPath
+  configPath,
+  configModule
 }) {
   useEffect(() => {
     const websocketUrl = new URL(apiUrl);
@@ -5222,18 +6131,21 @@ function useDev({
       await messageHandler.handleMessage(data);
     });
     let ctx;
+    let firstBuild = true;
     async function runBuild() {
       if (ctx) {
         await ctx.dispose();
       }
       let latestWorkerContentHash;
       const taskFiles = await gatherTaskFiles(config);
-      const workerFacadePath = join6(cliRootPath(), "workers", "dev", "worker-facade.js");
+      const workerFacadePath = join7(cliRootPath(), "workers", "dev", "worker-facade.js");
       const workerFacade = readFileSync3(workerFacadePath, "utf-8");
-      const workerSetupPath = join6(cliRootPath(), "workers", "dev", "worker-setup.js");
+      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)}";`
+        `import { tracingSDK, otelTracer, otelLogger, sender } from "${escapeImportPath(
+          workerSetupPath
+        )}";`
       );
       if (configPath) {
         configPath = normalize(configPath);
@@ -5250,7 +6162,6 @@ function useDev({
           `const importedConfig = undefined; const handleError = undefined;`
         );
       }
-      let firstBuild = true;
       logger.log(chalkGrey("\u25CB Building background worker\u2026"));
       ctx = await context2({
         stdin: {
@@ -5258,6 +6169,9 @@ function useDev({
           resolveDir: process.cwd(),
           sourcefile: "__entryPoint.ts"
         },
+        banner: {
+          js: `process.on("uncaughtException", function(error, origin) { if (error instanceof Error) { process.send && process.send({ type: "UNCAUGHT_EXCEPTION", payload: { error: { name: error.name, message: error.message, stack: error.stack }, origin }, version: "v1" }); } else { process.send && process.send({ type: "UNCAUGHT_EXCEPTION", payload: { error: { name: "Error", message: typeof error === "string" ? error : JSON.stringify(error) }, origin }, version: "v1" }); } });`
+        },
         bundle: true,
         metafile: true,
         write: false,
@@ -5275,6 +6189,7 @@ function useDev({
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
+          mockServerOnlyPlugin(),
           bundleTriggerDevCore("workerFacade", config.tsconfigPath),
           bundleDependenciesPlugin(
             "workerFacade",
@@ -5282,6 +6197,11 @@ function useDev({
             config.tsconfigPath
           ),
           workerSetupImportConfigPlugin(configPath),
+          esbuildDecorators3({
+            tsconfig: config.tsconfigPath,
+            tsx: true,
+            force: false
+          }),
           {
             name: "trigger.dev v3",
             setup(build3) {
@@ -5295,22 +6215,19 @@ function useDev({
                 if (!firstBuild) {
                   logger.log(chalkGrey("\u25CB Building background worker\u2026"));
                 }
-                const metaOutputKey = join6("out", `stdin.js`).replace(/\\/g, "/");
-                logger.debug("Metafile", {
-                  metafileOutputs: JSON.stringify(result.metafile?.outputs)
-                });
+                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 = join6(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 = join6(config.projectDir, `${metaOutputKey}.map`);
+                const sourceMapFileKey = join7(config.projectDir, `${metaOutputKey}.map`);
                 const sourceMapFile = result.outputFiles.find(
                   (file) => file.path === sourceMapFileKey
                 );
@@ -5321,14 +6238,14 @@ function useDev({
                   logger.log(chalkGrey("\u25CB No changes detected, skipping build\u2026"));
                   return;
                 }
-                const fullPath = join6(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}`);
-                const dependencies2 = await gatherRequiredDependencies2(metaOutput, config);
+                const dependencies2 = await gatherRequiredDependencies(metaOutput, config);
                 if (sourceMapFile) {
                   const sourceMapPath2 = `${fullPath}.map`;
                   await fs7.promises.writeFile(sourceMapPath2, sourceMapFile.text);
@@ -5345,15 +6262,23 @@ function useDev({
                     ...environmentVariablesResponse.success ? environmentVariablesResponse.data.variables : {}
                   },
                   debuggerOn,
-                  debugOtel
+                  debugOtel,
+                  resolveEnvVariables: createResolveEnvironmentVariablesFunction(configModule)
                 });
                 try {
                   await backgroundWorker.initialize();
                   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);
@@ -5372,6 +6297,9 @@ function useDev({
                     );
                     return;
                   }
+                  logger.debug("Creating background worker with tasks", {
+                    tasks: taskResources
+                  });
                   const backgroundWorkerBody = {
                     localOnly: true,
                     metadata: {
@@ -5415,10 +6343,10 @@ function useDev({
                       return;
                     } else {
                     }
-                    if (e.originalError.stack) {
+                    if (e.originalError.message || e.originalError.stack) {
                       logger.log(
                         `${chalkError("X Error:")} Worker failed to start`,
-                        e.originalError.stack
+                        e.originalError.stack ?? e.originalError.message
                       );
                     }
                     return;
@@ -5458,7 +6386,7 @@ ${chalkError("X Error:")} The package ${chalkPurple(
     }
     const throttledRebuild = pDebounce(runBuild, 250, { before: true });
     const taskFileWatcher = watch(
-      config.triggerDirectories.map((triggerDir) => `${triggerDir}/*.ts`),
+      config.triggerDirectories.map((triggerDir) => `${triggerDir}/**/*.ts`),
       {
         ignoreInitial: true
       }
@@ -5509,7 +6437,7 @@ function WebsocketFactory(apiKey) {
     }
   };
 }
-async function gatherRequiredDependencies2(outputMeta, config) {
+async function gatherRequiredDependencies(outputMeta, config) {
   const dependencies2 = {};
   logger.debug("Gathering required dependencies from imports", {
     imports: outputMeta.imports
@@ -5528,7 +6456,7 @@ async function gatherRequiredDependencies2(outputMeta, config) {
     }
   }
   if (config.additionalPackages) {
-    const projectPackageJson = await readJSONFile(join6(config.projectDir, "package.json"));
+    const projectPackageJson = await readJSONFile(join7(config.projectDir, "package.json"));
     for (const packageName of config.additionalPackages) {
       if (dependencies2[packageName]) {
         continue;
@@ -5598,7 +6526,7 @@ async function amendNodePathWithPnpmNodeModules(nodePath) {
 async function findPnpmNodeModulesPath() {
   return await findUp3(
     async (directory) => {
-      const pnpmModules = join6(directory, "node_modules", ".pnpm", "node_modules");
+      const pnpmModules = join7(directory, "node_modules", ".pnpm", "node_modules");
       const hasPnpmNodeModules = await pathExists2(pnpmModules);
       if (hasPnpmNodeModules) {
         return pnpmModules;
@@ -5607,20 +6535,38 @@ async function findPnpmNodeModulesPath() {
     { type: "directory" }
   );
 }
+var hasResolvedEnvVars = false;
+var resolvedEnvVars = {};
+function createResolveEnvironmentVariablesFunction(configModule) {
+  return async (env, worker) => {
+    if (hasResolvedEnvVars) {
+      return resolvedEnvVars;
+    }
+    const $resolvedEnvVars = await callResolveEnvVars(
+      configModule,
+      env,
+      "dev",
+      worker.params.projectConfig.project
+    );
+    if ($resolvedEnvVars) {
+      resolvedEnvVars = $resolvedEnvVars.variables;
+      hasResolvedEnvVars = true;
+    }
+    return resolvedEnvVars;
+  };
+}
 
 // src/commands/init.ts
-import { intro as intro4, isCancel, log as log4, outro as outro4, select as select2, 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 chalk6 from "chalk";
+import { flattenAttributes as flattenAttributes4 } from "@trigger.dev/core/v3";
+import { recordSpanException as recordSpanException6 } from "@trigger.dev/core/v3/workers";
+import chalk5 from "chalk";
 import { execa as execa3 } from "execa";
-import { applyEdits, modify } from "jsonc-parser";
+import { applyEdits, modify, findNodeAtLocation, parseTree, getNodeValue } from "jsonc-parser";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join7, relative as relative4, resolve as resolve3 } from "node:path";
-import terminalLink3 from "terminal-link";
+import { join as join8, relative as relative4, resolve as resolve5 } from "node:path";
+import terminalLink4 from "terminal-link";
 import { z as z6 } from "zod";
 
 // src/utilities/createFileFromTemplate.ts
@@ -5695,7 +6641,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,
@@ -5719,7 +6665,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;
@@ -5733,58 +6679,58 @@ async function _initCommand(dir, options) {
     options.projectRef
   );
   span?.setAttributes({
-    ...flattenAttributes3(selectedProject, "cli.project")
+    ...flattenAttributes4(selectedProject, "cli.project")
   });
   logger.debug("Selected project", selectedProject);
-  log4.step(`Configuring project "${selectedProject.name}" (${selectedProject.externalRef})`);
+  log6.step(`Configuring project "${selectedProject.name}" (${selectedProject.externalRef})`);
   if (!options.skipPackageInstall) {
     await installPackages2(dir, options);
   } else {
-    log4.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}`
   );
-  log4.success("Successfully initialized project for Trigger.dev v3 \u{1FAE1}");
-  log4.info("Next steps:");
-  log4.info(
-    `   1. To start developing, run ${chalk6.green(
+  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`
   );
-  log4.info(`   2. Visit your ${projectDashboard} to view your newly created tasks.`);
-  log4.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.`
   );
-  log4.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 ${chalk6.cyan("help@trigger.dev")}`
+    )} 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 = join7(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 = resolve5(process.cwd(), location);
       logger.debug({ triggerDir });
       span.setAttributes({
         "cli.triggerDir": triggerDir
@@ -5803,7 +6749,7 @@ async function createTriggerDir(dir, options) {
           }
         ]
       });
-      if (isCancel(exampleSelection)) {
+      if (isCancel2(exampleSelection)) {
         throw new OutroCommandError();
       }
       const example = exampleSelection;
@@ -5811,25 +6757,25 @@ async function createTriggerDir(dir, options) {
         "cli.example": example
       });
       if (example === "none") {
-        await createFile(join7(triggerDir, ".gitkeep"), "");
-        log4.step(`Created directory at ${location}`);
+        await createFile(join8(triggerDir, ".gitkeep"), "");
+        log6.step(`Created directory at ${location}`);
         span.end();
         return { location, isCustomValue: location !== defaultValue };
       }
-      const templatePath = join7(cliRootPath(), "templates", "examples", `${example}.ts.template`);
-      const outputPath = join7(triggerDir, "example.ts");
+      const templatePath = join8(cliRootPath(), "templates", "examples", `${example}.ts.template`);
+      const outputPath = join8(triggerDir, "example.ts");
       await createFileFromTemplate({
         templatePath,
         outputPath,
         replacements: {}
       });
       const relativeOutputPath = relative4(process.cwd(), outputPath);
-      log4.step(`Created example file at ${relativeOutputPath}`);
+      log6.step(`Created example file at ${relativeOutputPath}`);
       span.end();
       return { location, isCustomValue: location !== defaultValue };
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -5839,15 +6785,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 = join7(projectDir, ".gitignore");
+      const projectDir = resolve5(process.cwd(), dir);
+      const gitIgnorePath = join8(projectDir, ".gitignore");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.gitIgnorePath": gitIgnorePath
       });
       if (!await pathExists(gitIgnorePath)) {
         await createFile(gitIgnorePath, ".trigger");
-        log4.step(`Added .trigger to .gitignore`);
+        log6.step(`Added .trigger to .gitignore`);
         span.end();
         return;
       }
@@ -5859,11 +6805,11 @@ async function gitIgnoreDotTriggerDir(dir, options) {
       const newGitIgnoreContent = `${gitIgnoreContent}
 .trigger`;
       await writeFile3(gitIgnorePath, newGitIgnoreContent, "utf-8");
-      log4.step(`Added .trigger to .gitignore`);
+      log6.step(`Added .trigger to .gitignore`);
       span.end();
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -5873,14 +6819,30 @@ 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 = join7(projectDir, "tsconfig.json");
+      const projectDir = resolve5(process.cwd(), dir);
+      const tsconfigPath = join8(projectDir, "tsconfig.json");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.tsconfigPath": tsconfigPath
       });
       const tsconfigContent = await readFile(tsconfigPath);
-      const edits = modify(tsconfigContent, ["include", -1], "trigger.config.ts", {
+      const tsconfigContentTree = parseTree(tsconfigContent, void 0);
+      if (!tsconfigContentTree) {
+        span.end();
+        return;
+      }
+      const tsconfigIncludeOption = findNodeAtLocation(tsconfigContentTree, ["include"]);
+      if (!tsconfigIncludeOption) {
+        span.end();
+        return;
+      }
+      const tsConfigFileName = "trigger.config.ts";
+      const tsconfigIncludeOptionValue = getNodeValue(tsconfigIncludeOption);
+      if (tsconfigIncludeOptionValue.includes(tsConfigFileName)) {
+        span.end();
+        return;
+      }
+      const edits = modify(tsconfigContent, ["include", -1], tsConfigFileName, {
         isArrayInsertion: true,
         formattingOptions: {
           tabSize: 2,
@@ -5892,11 +6854,11 @@ async function addConfigFileToTsConfig(dir, options) {
       const newTsconfigContent = applyEdits(tsconfigContent, edits);
       logger.debug("new tsconfig.json content", { newTsconfigContent });
       await writeFile3(tsconfigPath, newTsconfigContent, "utf-8");
-      log4.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)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -5907,7 +6869,7 @@ async function installPackages2(dir, options) {
   return await tracer.startActiveSpan("installPackages", async (span) => {
     const installSpinner = spinner();
     try {
-      const projectDir = resolve3(process.cwd(), dir);
+      const projectDir = resolve5(process.cwd(), dir);
       const pkgManager = await getUserPackageManager(projectDir);
       span.setAttributes({
         "cli.projectDir": projectDir,
@@ -5947,7 +6909,7 @@ async function installPackages2(dir, options) {
         `Failed to install @trigger.dev/sdk@${options.tag}. Rerun command with --log-level debug for more details.`
       );
       if (!(e instanceof SkipCommandError)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -5959,9 +6921,9 @@ async function writeConfigFile(dir, project, options, triggerDir) {
     try {
       const spnnr = spinner();
       spnnr.start("Creating config file");
-      const projectDir = resolve3(process.cwd(), dir);
-      const templatePath = join7(cliRootPath(), "templates", "trigger.config.ts.template");
-      const outputPath = join7(projectDir, "trigger.config.ts");
+      const projectDir = resolve5(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,
@@ -5988,7 +6950,7 @@ async function writeConfigFile(dir, project, options, triggerDir) {
       return result.success;
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -6001,13 +6963,13 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
       if (projectRef) {
         const projectResponse = await apiClient2.getProject(projectRef);
         if (!projectResponse.success) {
-          log4.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);
         }
         span.setAttributes({
-          ...flattenAttributes3(projectResponse.data, "cli.project")
+          ...flattenAttributes4(projectResponse.data, "cli.project")
         });
         span.end();
         return projectResponse.data;
@@ -6017,11 +6979,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({
@@ -6032,7 +6994,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(
@@ -6042,13 +7004,13 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
         throw new Error("Invalid project ref");
       }
       span.setAttributes({
-        ...flattenAttributes3(projectData, "cli.project")
+        ...flattenAttributes4(projectData, "cli.project")
       });
       span.end();
       return projectData;
     } catch (e) {
       if (!(e instanceof SkipCommandError)) {
-        recordSpanException5(span, e);
+        recordSpanException6(span, e);
       }
       span.end();
       throw e;
@@ -6084,7 +7046,7 @@ async function logout(options) {
 }
 
 // src/commands/list-profiles.ts
-import { log as log5, outro as outro5 } from "@clack/prompts";
+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(
@@ -6110,12 +7072,12 @@ async function listProfiles(options) {
     return;
   }
   const profiles = Object.keys(authConfig);
-  log5.message("Profiles:");
+  log7.message("Profiles:");
   for (const profile of profiles) {
     const profileConfig = authConfig[profile];
-    log5.info(`${profile}${profileConfig?.apiUrl ? ` - ${chalkGrey(profileConfig.apiUrl)}` : ""}`);
+    log7.info(`${profile}${profileConfig?.apiUrl ? ` - ${chalkGrey(profileConfig.apiUrl)}` : ""}`);
   }
-  outro5("Retrieve account info by running whoami --profile <profile>");
+  outro7("Retrieve account info by running whoami --profile <profile>");
 }
 
 // src/cli/index.ts
@@ -6128,6 +7090,7 @@ configureDeployCommand(program);
 configureWhoamiCommand(program);
 configureLogoutCommand(program);
 configureListProfilesCommand(program);
+configureUpdateCommand(program);
 
 // src/index.ts
 var main = async () => {