trigger.dev 0.0.0-v3-trigger-dirs-20240423123825 → 0.0.0-v3-update-command-20240423145551

package/dist/index.js

@@ -777,15 +777,15 @@ 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 outro4 } from "@clack/prompts";
 import { depot } from "@depot/cli";
 import { context, trace as trace2 } from "@opentelemetry/api";
 import {
   TaskMetadataFailedToParseData,
   detectDependencyVersion,
-  flattenAttributes as flattenAttributes2
+  flattenAttributes as flattenAttributes2,
+  recordSpanException as recordSpanException4
 } from "@trigger.dev/core/v3";
-import { recordSpanException as recordSpanException4 } from "@trigger.dev/core/v3/workers";
 import chalk5 from "chalk";
 import { Option as CommandOption } from "commander";
 import { build as build2 } from "esbuild";
@@ -793,14 +793,14 @@ 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, relative as relative3, posix } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import terminalLink2 from "terminal-link";
 import invariant from "tiny-invariant";
 import { z as z4 } from "zod";
 
 // package.json
-var version = "0.0.0-v3-trigger-dirs-20240423123825";
+var version = "0.0.0-v3-update-command-20240423145551";
 var dependencies = {
   "@clack/prompts": "^0.7.0",
   "@depot/cli": "0.0.1-cli.2.55.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-v3-trigger-dirs-20240423123825",
+  "@trigger.dev/core": "workspace:0.0.0-v3-update-command-20240423145551",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -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",
@@ -1141,8 +1140,7 @@ async function zodfetch(schema, url, requestInit) {
 }
 
 // src/cli/common.ts
-import { flattenAttributes } from "@trigger.dev/core/v3";
-import { recordSpanException } from "@trigger.dev/core/v3/workers";
+import { flattenAttributes, recordSpanException } from "@trigger.dev/core/v3";
 import { z } from "zod";
 
 // src/telemetry/tracing.ts
@@ -1319,6 +1317,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";
@@ -1367,6 +1366,18 @@ function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
   formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
   return formattedDate;
 }
+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({
@@ -1475,6 +1486,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");
 }
@@ -1482,8 +1496,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");
@@ -1541,12 +1555,9 @@ 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) || entry.name.startsWith("."))
+    if (!entry.isDirectory() || IGNORED_DIRS.includes(entry.name))
       continue;
     const fullPath = join(dirPath, entry.name);
-    if (fullPath.endsWith("app/api/trigger")) {
-      continue;
-    }
     if (entry.name === "trigger") {
       triggerDirectories.push(fullPath);
     }
@@ -1620,15 +1631,6 @@ 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);
@@ -1681,7 +1683,6 @@ async function resolveConfig(path7, config) {
     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;
   }
@@ -1689,7 +1690,7 @@ async function resolveConfig(path7, config) {
     config.projectDir = path7;
   }
   if (!config.tsconfigPath) {
-    config.tsconfigPath = await findFilePath(path7, "tsconfig.json");
+    config.tsconfigPath = await getConfigPath(path7, "tsconfig.json");
   }
   return config;
 }
@@ -1715,29 +1716,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;
@@ -1747,7 +1748,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(
@@ -1762,9 +1763,10 @@ After installation, run Trigger.dev with \`npx trigger.dev\`.`
   }
 }
 async function printStandloneInitialBanner(performUpdateCheck = true) {
-  const packageVersion = getVersion();
+  const cliVersion = getVersion();
   logger.log(`
-${logo()} ${chalkGrey("(v3 Developer Preview)")}`);
+${logo()} ${chalkGrey(`(${cliVersion})`)}
+`);
   if (performUpdateCheck) {
     const maybeNewVersion = await updateCheck();
     if (maybeNewVersion !== void 0) {
@@ -1773,7 +1775,10 @@ ${logo()} ${chalkGrey("(v3 Developer Preview)")}`);
   }
   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"
@@ -1785,7 +1790,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) {
   }
@@ -1854,8 +1859,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/workers";
+import { intro as intro2, log as log3, outro as outro2, select } from "@clack/prompts";
+import { recordSpanException as recordSpanException3 } from "@trigger.dev/core/v3";
 
 // ../../node_modules/.pnpm/open@10.0.3/node_modules/open/index.js
 import process6 from "node:process";
@@ -2225,14 +2230,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve4(subprocess);
+        resolve5(subprocess);
       });
     });
   }
@@ -2349,7 +2354,7 @@ var decorateErrorWithCounts = (error, attemptNumber, options) => {
   return error;
 };
 async function pRetry(input, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     options = {
       onFailedAttempt() {
       },
@@ -2372,7 +2377,7 @@ async function pRetry(input, options) {
       try {
         const result = await input(attemptNumber);
         cleanUp();
-        resolve4(result);
+        resolve5(result);
       } catch (error) {
         try {
           if (!(error instanceof Error)) {
@@ -2405,7 +2410,7 @@ import { z as z3 } from "zod";
 import { intro, note } from "@clack/prompts";
 
 // src/utilities/session.ts
-import { recordSpanException as recordSpanException2 } from "@trigger.dev/core/v3/workers";
+import { recordSpanException as recordSpanException2 } from "@trigger.dev/core/v3";
 var tracer2 = getTracer();
 async function isLoggedIn(profile = "default") {
   return await tracer2.startActiveSpan("isLoggedIn", async (span) => {
@@ -2647,11 +2652,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)}`
       );
@@ -2685,7 +2690,7 @@ ${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");
         }
@@ -2704,7 +2709,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();
@@ -2789,7 +2794,7 @@ function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
     name: "trigger-bundle-core",
     setup(build3) {
       build3.onResolve({ filter: /.*/ }, (args) => {
-        if (!args.path.startsWith("@trigger.dev/core/v3")) {
+        if (args.path !== "@trigger.dev/core/v3") {
           return void 0;
         }
         const triggerSdkPath = __require.resolve("@trigger.dev/sdk/v3", { paths: [process.cwd()] });
@@ -2797,14 +2802,17 @@ function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
           ...args,
           triggerSdkPath
         });
-        const resolvedPath = __require.resolve(args.path, {
+        const resolvedPath = __require.resolve("@trigger.dev/core/v3", {
           paths: [triggerSdkPath]
         });
-        logger.debug(`[${buildIdentifier}][trigger-bundle-core] Externalizing ${args.path}`, {
-          ...args,
-          triggerSdkPath,
-          resolvedPath
-        });
+        logger.debug(
+          `[${buildIdentifier}][trigger-bundle-core] Externalizing @trigger.dev/core/v3`,
+          {
+            ...args,
+            triggerSdkPath,
+            resolvedPath
+          }
+        );
         return {
           path: resolvedPath,
           external: false
@@ -3128,7 +3136,13 @@ 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) {
@@ -3150,19 +3164,33 @@ 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
@@ -3221,17 +3249,25 @@ 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 resolve(packageName, options) {
     if (BuiltInModules.has(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") {
@@ -3243,7 +3279,7 @@ var JavascriptProject = class {
         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
@@ -3258,16 +3294,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}`, { result });
     for (const dep of result) {
       const dependency = dep.dependencies?.[packageName];
       if (dependency) {
@@ -3280,11 +3341,17 @@ 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);
   }
   #recursivelySearchDependencies(dependencies2, packageName) {
@@ -3305,11 +3372,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}`, { lines });
     for (const line of lines) {
       const json = JSON.parse(line);
       if (json.value === packageName) {
@@ -3328,6 +3401,204 @@ function cliRootPath() {
   return __dirname2;
 }
 
+// src/commands/update.ts
+import { confirm, intro as intro3, isCancel, log as log4, outro as outro3 } 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) {
+  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;
+  }
+  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"
+    );
+  }
+  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) {
+      outro3(`Nothing to do${newCliVersion ? " ..but you should really update your CLI!" : ""}`);
+    }
+    return;
+  }
+  prettyWarning(
+    "Mismatch between your CLI version and installed packages",
+    "We recommend pinned versions for guaranteed compatibility"
+  );
+  if (!process.stdout.isTTY) {
+    outro3("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 add the \`trigger.dev\` package to your dependencies. You will also have to update your workflow deploy command to \`npx trigger.dev deploy\` to ensure your pinned CLI version is used.
+
+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) {
+      outro3("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) {
+      outro3("You've been warned!");
+    }
+    return;
+  }
+  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) {
+    outro3(
+      `Packages updated${newCliVersion ? " ..but you should really update your CLI too!" : ""}`
+    );
+  }
+}
+function getTriggerDependencies(packageJson) {
+  const deps = [];
+  for (const type of ["dependencies", "devDependencies"]) {
+    for (const [name, version2] of Object.entries(packageJson[type] ?? {})) {
+      if (!version2) {
+        continue;
+      }
+      if (version2.startsWith("workspace")) {
+        continue;
+      }
+      if (!triggerPackageFilter.test(name)) {
+        continue;
+      }
+      const ignoredPackages = ["@trigger.dev/companyicons"];
+      if (ignoredPackages.includes(name)) {
+        continue;
+      }
+      deps.push({ type, name, version: version2 });
+    }
+  }
+  return deps;
+}
+function mutatePackageJsonWithUpdatedPackages(packageJson, depsToUpdate, targetVersion) {
+  for (const { type, name, version: version2 } of depsToUpdate) {
+    if (!packageJson[type]) {
+      throw new Error(
+        `No ${type} entry found in package.json. Please try to upgrade manually instead.`
+      );
+    }
+    packageJson[type][name] = targetVersion;
+  }
+}
+function printUpdateTable(depsToUpdate, targetVersion) {
+  log4.message("Suggested updates");
+  const tableData = depsToUpdate.map((dep) => ({
+    package: dep.name,
+    old: dep.version,
+    new: targetVersion
+  }));
+  logger.table(tableData);
+}
+async function updateConfirmation(depsToUpdate, targetVersion) {
+  printUpdateTable(depsToUpdate, targetVersion);
+  let confirmMessage = "Would you like to apply those updates?";
+  return await confirm({
+    message: confirmMessage
+  });
+}
+async function getPackageJson(absoluteProjectPath) {
+  const packageJsonPath = join5(absoluteProjectPath, "package.json");
+  const readonlyPackageJson = Object.freeze(await readJSONFile(packageJsonPath));
+  const packageJson = structuredClone(readonlyPackageJson);
+  return { packageJson, readonlyPackageJson, packageJsonPath };
+}
+
 // src/commands/deploy.ts
 var DeployCommandOptions = CommonCommandOptions.extend({
   skipTypecheck: z4.boolean().default(false),
@@ -3343,7 +3614,8 @@ var DeployCommandOptions = CommonCommandOptions.extend({
   projectRef: z4.string().optional(),
   outputMetafile: z4.string().optional(),
   apiUrl: z4.string().optional(),
-  saveLogs: z4.boolean().default(false)
+  saveLogs: z4.boolean().default(false),
+  skipUpdateCheck: z4.boolean().default(false)
 });
 function configureDeployCommand(program2) {
   return commonOptions(
@@ -3351,7 +3623,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(
+    ).option("--skip-typecheck", "Whether to skip the pre-build typecheck").option("--skip-update-check", "Skip checking for @trigger.dev package updates").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(
@@ -3409,7 +3681,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,
@@ -3452,7 +3727,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(
@@ -3555,7 +3830,7 @@ async function _deployCommand(dir, options) {
     printWarnings(warnings.warnings);
     if (options.saveLogs) {
       const logPath = await saveLogs(deploymentResponse.data.shortCode, image.logs);
-      log3.info(`Build logs have been saved to ${logPath}`);
+      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}` : ""}`;
@@ -3612,11 +3887,11 @@ async function _deployCommand(dir, options) {
       await preExitTasks();
       const taskCount = finishedDeployment.worker?.tasks.length ?? 0;
       if (taskCount === 0) {
-        outro3(
+        outro4(
           `Version ${version2} deployed with no detected tasks. Please make sure you are exporting tasks in your project. ${deploymentLink}`
         );
       } else {
-        outro3(
+        outro4(
           `Version ${version2} deployed with ${taskCount} detected task${taskCount === 1 ? "" : "s"} ${deploymentLink}`
         );
       }
@@ -3672,12 +3947,12 @@ async function _deployCommand(dir, options) {
 }
 function printErrors(errors) {
   for (const error of errors ?? []) {
-    log3.error(`${chalkError("Error:")} ${error}`);
+    log5.error(`${chalkError("Error:")} ${error}`);
   }
 }
 function printWarnings(warnings) {
   for (const warning of warnings ?? []) {
-    log3.warn(`${chalkWarning("Warning:")} ${warning}`);
+    log5.warn(`${chalkWarning("Warning:")} ${warning}`);
   }
 }
 function checkLogsForWarnings(logs) {
@@ -3751,7 +4026,7 @@ If it's a binary:  Please ${terminalLink2(
       continue;
     }
     const message = getMessageFromTemplate(error.message, matches.groups);
-    log3.error(`${chalkError("Error:")} ${message}`);
+    log5.error(`${chalkError("Error:")} ${message}`);
     break;
   }
 }
@@ -3765,7 +4040,7 @@ function getMessageFromTemplate(template, replacer) {
   return message;
 }
 async function saveLogs(shortCode, logs) {
-  const logPath = join5(await createTempDir(), `build-${shortCode}.log`);
+  const logPath = join6(await createTempDir(), `build-${shortCode}.log`);
   await writeFile2(logPath, logs);
   return logPath;
 }
@@ -3776,9 +4051,9 @@ async function failDeploy(shortCode, errorSummary, logs, deploymentSpinner, warn
     printWarnings(warnings);
     printErrors(errors);
     checkLogsForErrors(logs);
-    outro3(`${chalkError("Error:")} ${errorSummary}. Full build logs have been saved to ${logPath}`);
+    outro4(`${chalkError("Error:")} ${errorSummary}. Full build logs have been saved to ${logPath}`);
   } else {
-    outro3(`${chalkError("Error:")} ${errorSummary}.`);
+    outro4(`${chalkError("Error:")} ${errorSummary}.`);
   }
 }
 async function checkEnvVars(envVars, config, options, environmentClient, apiUrl) {
@@ -4099,10 +4374,10 @@ 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", "prod", "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)}";`
@@ -4162,10 +4437,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({
@@ -4208,7 +4483,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
         );
       }
@@ -4219,24 +4494,24 @@ 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
@@ -4253,11 +4528,11 @@ async function compileProject(config, options, configPath) {
           ...javascriptProject.scripts
         }
       };
-      await writeJSONFile(join5(tempDir, "package.json"), packageJsonContents);
+      await writeJSONFile(join6(tempDir, "package.json"), packageJsonContents);
       const copyResult = await copyAdditionalFiles(config, tempDir);
       if (!copyResult.ok) {
         compileSpinner.stop("Project built with warnings");
-        log3.warn(
+        log5.warn(
           `No additionalFiles matches for:
 
 ${copyResult.noMatches.map((glob) => `- "${glob}"`).join("\n")}
@@ -4279,8 +4554,8 @@ If this is unexpected you should check your ${terminalLink2(
       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");
+      await copyFile(containerFilePath, join6(tempDir, "Containerfile"));
       const contentHasher = createHash("sha256");
       contentHasher.update(Buffer.from(entryPointOutputFile.text));
       contentHasher.update(Buffer.from(workerOutputFile.text));
@@ -4312,8 +4587,8 @@ 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,
@@ -4322,7 +4597,7 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
     try {
       const cachedPackageLock = await readFile2(cachePath, "utf-8");
       logger.debug(`Using cached package-lock.json for ${digest}`);
-      await writeFile2(join5(projectDir, "package-lock.json"), cachedPackageLock);
+      await writeFile2(join6(projectDir, "package-lock.json"), cachedPackageLock);
       span.setAttributes({
         "cache.hit": true
       });
@@ -4345,11 +4620,11 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
           cwd: projectDir,
           stdio: logger.loggerLevel === "debug" ? "inherit" : "pipe"
         });
-        const packageLockContents = await readFile2(join5(projectDir, "package-lock.json"), "utf-8");
+        const packageLockContents = await readFile2(join6(projectDir, "package-lock.json"), "utf-8");
         logger.debug(`Writing package-lock.json to cache for ${digest}`);
         await mkdir(cacheDir, { recursive: true });
         await writeFile2(cachePath, packageLockContents);
-        await writeFile2(join5(projectDir, "package-lock.json"), packageLockContents);
+        await writeFile2(join6(projectDir, "package-lock.json"), packageLockContents);
         span.end();
         resolvingDepsSpinner.stop("Dependencies resolved");
         return true;
@@ -4401,8 +4676,8 @@ async function typecheckProject(config, options) {
       tscTypecheck.stdout?.on("data", (chunk) => stdouts.push(chunk.toString()));
       tscTypecheck.stderr?.on("data", (chunk) => stderrs.push(chunk.toString()));
       try {
-        await new Promise((resolve4, reject) => {
-          tscTypecheck.addListener("exit", (code) => code === 0 ? resolve4(code) : reject(code));
+        await new Promise((resolve5, reject) => {
+          tscTypecheck.addListener("exit", (code) => code === 0 ? resolve5(code) : reject(code));
         });
       } catch (error) {
         typecheckSpinner.stop(
@@ -4520,7 +4795,7 @@ async function copyAdditionalFiles(config, tempDir) {
           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 = join5(tempDir, pathInsideTempDir);
+            const relativeDestinationPath = join6(tempDir, pathInsideTempDir);
             logger.debug(`Copying file ${file.fullpath()} to ${relativeDestinationPath}`);
             await mkdir(dirname(relativeDestinationPath), { recursive: true });
             await copyFile(file.fullpath(), relativeDestinationPath);
@@ -4551,7 +4826,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]: {
@@ -4586,17 +4861,18 @@ function arrayToSentence(items) {
 
 // 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";
@@ -4625,16 +4901,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 { dirname as dirname2, resolve as resolve3 } from "node:path";
 import terminalLink3 from "terminal-link";
 var BackgroundWorkerCoordinator = class {
   constructor(baseURL) {
@@ -4834,7 +5111,7 @@ var BackgroundWorker = class {
       ...this.#readEnvVars()
     };
     logger.debug("Initializing worker", { path: this.path, cwd, fullEnv });
-    this.tasks = await new Promise((resolve4, reject) => {
+    this.tasks = await new Promise((resolve5, reject) => {
       const child = fork(this.path, {
         stdio: [
           /*stdin*/
@@ -4861,7 +5138,7 @@ var BackgroundWorker = class {
         if (message.type === "TASKS_READY" && !resolved) {
           clearTimeout(timeout);
           resolved = true;
-          resolve4(message.payload.tasks);
+          resolve5(message.payload.tasks);
           child.kill();
         } else if (message.type === "UNCAUGHT_EXCEPTION") {
           clearTimeout(timeout);
@@ -4996,7 +5273,7 @@ var BackgroundWorker = class {
     const result = {};
     dotenv.config({
       processEnv: result,
-      path: [".env", ".env.local", ".env.development.local"].map((p) => resolve2(process.cwd(), p))
+      path: [".env", ".env.local", ".env.development.local"].map((p) => resolve3(process.cwd(), p))
     });
     process.env.TRIGGER_API_URL && (result.TRIGGER_API_URL = process.env.TRIGGER_API_URL);
     delete result.TRIGGER_API_URL;
@@ -5097,8 +5374,8 @@ var TaskRunProcess = class {
   async executeTaskRun(payload) {
     let resolver;
     let rejecter;
-    const promise = new Promise((resolve4, reject) => {
-      resolver = resolve4;
+    const promise = new Promise((resolve5, reject) => {
+      resolver = resolve5;
       rejecter = reject;
     });
     this._attemptStatuses.set(payload.execution.attempt.id, "PENDING");
@@ -5244,14 +5521,15 @@ 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);
@@ -5293,7 +5571,11 @@ async function startDev(dir, options, authorization, dashboardUrl) {
       logger.loggerLevel = options.logLevel;
     }
     await printStandloneInitialBanner(true);
-    printDevBanner();
+    if (!options.skipUpdateCheck) {
+      console.log();
+      await updateTriggerPackages(dir, { ...options }, false, true);
+    }
+    printDevBanner(!options.skipUpdateCheck);
     logger.debug("Starting dev session", { dir, options, authorization });
     let config = await readConfig(dir, {
       projectRef: options.projectRef,
@@ -5458,9 +5740,9 @@ function useDev({
       }
       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)}";`
@@ -5525,7 +5807,7 @@ function useDev({
                 if (!firstBuild) {
                   logger.log(chalkGrey("\u25CB Building background worker\u2026"));
                 }
-                const metaOutputKey = join6("out", `stdin.js`).replace(/\\/g, "/");
+                const metaOutputKey = join7("out", `stdin.js`).replace(/\\/g, "/");
                 logger.debug("Metafile", {
                   metafileOutputs: JSON.stringify(result.metafile?.outputs)
                 });
@@ -5533,14 +5815,14 @@ function useDev({
                 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
                 );
@@ -5551,10 +5833,10 @@ 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}`);
@@ -5758,7 +6040,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;
@@ -5828,7 +6110,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;
@@ -5839,15 +6121,17 @@ async function findPnpmNodeModulesPath() {
 }
 
 // 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 outro5, select as select2, text } from "@clack/prompts";
 import { context as context3, trace as trace3 } from "@opentelemetry/api";
-import { flattenAttributes as flattenAttributes3 } from "@trigger.dev/core/v3";
-import { recordSpanException as recordSpanException5 } from "@trigger.dev/core/v3/workers";
+import {
+  flattenAttributes as flattenAttributes3,
+  recordSpanException as recordSpanException5
+} from "@trigger.dev/core/v3";
 import chalk6 from "chalk";
 import { execa as execa3 } from "execa";
 import { applyEdits, modify } from "jsonc-parser";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join7, relative as relative4, resolve as resolve3 } from "node:path";
+import { join as join8, relative as relative4, resolve as resolve4 } from "node:path";
 import terminalLink4 from "terminal-link";
 import { z as z6 } from "zod";
 
@@ -5923,7 +6207,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,
@@ -5947,7 +6231,7 @@ async function _initCommand(dir, options) {
   if (!options.overrideConfig) {
     try {
       const result = await readConfig(dir);
-      outro4(
+      outro5(
         result.status === "file" ? `Project already initialized: Found config file at ${result.path}. Pass --override-config to override` : "Project already initialized"
       );
       return;
@@ -5964,11 +6248,11 @@ async function _initCommand(dir, options) {
     ...flattenAttributes3(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);
@@ -5978,41 +6262,41 @@ async function _initCommand(dir, options) {
     "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(
+  log6.success("Successfully initialized project for Trigger.dev v3 \u{1FAE1}");
+  log6.info("Next steps:");
+  log6.info(
     `   1. To start developing, run ${chalk6.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(
+  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(
+  log6.info(
     `   4. Need help? Join our ${terminalLink4(
       "Discord community",
       "https://trigger.dev/discord"
     )} or email us at ${chalk6.cyan("help@trigger.dev")}`
   );
-  outro4(`Project initialized successfully. Happy coding!`);
+  outro5(`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 = resolve4(process.cwd(), location);
       logger.debug({ triggerDir });
       span.setAttributes({
         "cli.triggerDir": triggerDir
@@ -6031,7 +6315,7 @@ async function createTriggerDir(dir, options) {
           }
         ]
       });
-      if (isCancel(exampleSelection)) {
+      if (isCancel2(exampleSelection)) {
         throw new OutroCommandError();
       }
       const example = exampleSelection;
@@ -6039,20 +6323,20 @@ 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) {
@@ -6067,15 +6351,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 = resolve4(process.cwd(), dir);
+      const gitIgnorePath = join8(projectDir, ".gitignore");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.gitIgnorePath": gitIgnorePath
       });
       if (!await pathExists(gitIgnorePath)) {
         await createFile(gitIgnorePath, ".trigger");
-        log4.step(`Added .trigger to .gitignore`);
+        log6.step(`Added .trigger to .gitignore`);
         span.end();
         return;
       }
@@ -6087,7 +6371,7 @@ 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)) {
@@ -6101,8 +6385,8 @@ async function gitIgnoreDotTriggerDir(dir, options) {
 async function addConfigFileToTsConfig(dir, options) {
   return await tracer.startActiveSpan("createTriggerDir", async (span) => {
     try {
-      const projectDir = resolve3(process.cwd(), dir);
-      const tsconfigPath = join7(projectDir, "tsconfig.json");
+      const projectDir = resolve4(process.cwd(), dir);
+      const tsconfigPath = join8(projectDir, "tsconfig.json");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.tsconfigPath": tsconfigPath
@@ -6120,7 +6404,7 @@ 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)) {
@@ -6135,7 +6419,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 = resolve4(process.cwd(), dir);
       const pkgManager = await getUserPackageManager(projectDir);
       span.setAttributes({
         "cli.projectDir": projectDir,
@@ -6187,9 +6471,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 = resolve4(process.cwd(), dir);
+      const templatePath = join8(cliRootPath(), "templates", "trigger.config.ts.template");
+      const outputPath = join8(projectDir, "trigger.config.ts");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.templatePath": templatePath,
@@ -6229,7 +6513,7 @@ 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);
@@ -6249,7 +6533,7 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
           "Create new project",
           `${dashboardUrl}/projects/new?version=v3`
         );
-        outro4(`You don't have any projects yet. ${newProjectLink}`);
+        outro5(`You don't have any projects yet. ${newProjectLink}`);
         throw new SkipCommandError();
       }
       const selectedProject = await select2({
@@ -6260,7 +6544,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(
@@ -6312,7 +6596,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 outro6 } from "@clack/prompts";
 var ListProfilesOptions = CommonCommandOptions;
 function configureListProfilesCommand(program2) {
   return program2.command("list-profiles").description("List all of your CLI profiles").option(
@@ -6338,12 +6622,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>");
+  outro6("Retrieve account info by running whoami --profile <profile>");
 }
 
 // src/cli/index.ts
@@ -6356,6 +6640,7 @@ configureDeployCommand(program);
 configureWhoamiCommand(program);
 configureLogoutCommand(program);
 configureListProfilesCommand(program);
+configureUpdateCommand(program);
 
 // src/index.ts
 var main = async () => {