trigger.dev 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/index.js

@@ -781,11 +781,12 @@ import { intro as intro3, log as log2, outro as outro3, spinner as spinner4 } fr
 import { depot } from "@depot/cli";
 import { context, trace as trace2 } from "@opentelemetry/api";
 import {
+  TaskMetadataFailedToParseData,
   detectDependencyVersion,
   flattenAttributes as flattenAttributes2,
   recordSpanException as recordSpanException4
 } from "@trigger.dev/core/v3";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import { Option as CommandOption } from "commander";
 import { build as build2 } from "esbuild";
 import { execa as execa2 } from "execa";
@@ -793,14 +794,14 @@ import { resolve as importResolve } from "import-meta-resolve";
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
 import { copyFile, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, join as join4, relative as relative2 } from "node:path";
+import { dirname, join as join5, relative as relative3 } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import terminalLink from "terminal-link";
 import invariant from "tiny-invariant";
 import { z as z4 } from "zod";
 
 // package.json
-var version = "3.0.0-beta.1";
+var version = "3.0.0-beta.11";
 var dependencies = {
   "@clack/prompts": "^0.7.0",
   "@depot/cli": "0.0.1-cli.2.55.0",
@@ -816,7 +817,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-base": "^1.22.0",
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
-  "@trigger.dev/core": "workspace:^3.0.0-beta.0",
+  "@trigger.dev/core": "workspace:^3.0.0-beta.11",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -833,7 +834,6 @@ var dependencies = {
   "import-meta-resolve": "^4.0.0",
   ink: "^4.4.1",
   "jsonc-parser": "^3.2.1",
-  jsonlines: "^0.1.1",
   liquidjs: "^10.9.2",
   "mock-fs": "^5.2.0",
   nanoid: "^4.0.2",
@@ -850,7 +850,6 @@ var dependencies = {
   "simple-git": "^3.19.0",
   "socket.io-client": "^4.7.4",
   "source-map-support": "^0.5.21",
-  "supports-color": "^9.4.0",
   "terminal-link": "^3.0.0",
   "tiny-invariant": "^1.2.0",
   "tsconfig-paths": "^4.2.0",
@@ -894,13 +893,12 @@ var package_default = {
   type: "module",
   exports: "./dist/index.js",
   bin: {
-    "trigger.dev": "./dist/index.js"
+    triggerdev: "./dist/index.js"
   },
   devDependencies: {
     "@trigger.dev/core-apps": "workspace:*",
     "@trigger.dev/tsconfig": "workspace:*",
     "@types/gradient-string": "^1.1.2",
-    "@types/jsonlines": "^0.1.5",
     "@types/mock-fs": "^4.13.1",
     "@types/node": "18",
     "@types/object-hash": "^3.0.6",
@@ -1307,7 +1305,7 @@ var Logger = class {
     const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
     if (kind) {
       const [firstLine, ...otherLines] = message.split("\n");
-      const notes = otherLines.length > 0 ? otherLines.map((text2) => ({ text: text2 })) : void 0;
+      const notes = otherLines.length > 0 ? otherLines.map((text3) => ({ text: text3 })) : void 0;
       return formatMessagesSync([{ text: firstLine, notes }], {
         color: true,
         kind,
@@ -1322,6 +1320,58 @@ var logger = new Logger();
 
 // src/cli/common.ts
 import { outro } from "@clack/prompts";
+
+// src/utilities/cliOutput.ts
+import chalk2 from "chalk";
+var green = "#4FFF54";
+var purple = "#735BF3";
+function chalkGreen(text3) {
+  return chalk2.hex(green)(text3);
+}
+function chalkPurple(text3) {
+  return chalk2.hex(purple)(text3);
+}
+function chalkGrey(text3) {
+  return chalk2.hex("#878C99")(text3);
+}
+function chalkError(text3) {
+  return chalk2.hex("#E11D48")(text3);
+}
+function chalkWarning(text3) {
+  return chalk2.yellow(text3);
+}
+function chalkSuccess(text3) {
+  return chalk2.hex("#28BF5C")(text3);
+}
+function chalkLink(text3) {
+  return chalk2.underline.hex("#D7D9DD")(text3);
+}
+function chalkWorker(text3) {
+  return chalk2.hex("#FFFF89")(text3);
+}
+function chalkTask(text3) {
+  return chalk2.hex("#60A5FA")(text3);
+}
+function chalkRun(text3) {
+  return chalk2.hex("#A78BFA")(text3);
+}
+function logo() {
+  return `${chalk2.hex(green).bold("Trigger")}${chalk2.hex(purple).bold(".dev")}`;
+}
+function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
+  let formattedDate = new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).format(date);
+  formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
+  return formattedDate;
+}
+
+// src/cli/common.ts
 var CommonCommandOptions = z.object({
   apiUrl: z.string().optional(),
   logLevel: z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log"),
@@ -1331,7 +1381,7 @@ var CommonCommandOptions = z.object({
 function commonOptions(command) {
   return command.option("--profile <profile>", "The login profile to use", "default").option("-a, --api-url <value>", "Override the API URL", "https://api.trigger.dev").option(
     "-l, --log-level <level>",
-    "The log level to use (debug, info, log, warn, error, none)",
+    "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
     "log"
   ).option("--skip-telemetry", "Opt-out of sending telemetry");
 }
@@ -1377,7 +1427,7 @@ async function wrapCommandAction(name, schema, options, action) {
       } else if (e instanceof SkipCommandError) {
       } else {
         recordSpanException(span, e);
-        logger.error(e instanceof Error ? e.message : String(e));
+        logger.log(`${chalkError("X Error:")} ${e instanceof Error ? e.message : String(e)}`);
       }
       span.end();
       throw e;
@@ -1535,6 +1585,11 @@ function readAuthConfigProfile(profile = "default") {
     return void 0;
   }
 }
+function deleteAuthConfigProfile(profile = "default") {
+  const existingConfig = readAuthConfigFile() || {};
+  delete existingConfig[profile];
+  writeAuthConfigFile(existingConfig);
+}
 function readAuthConfigFile() {
   try {
     const authConfigFilePath = getAuthConfigFilePath();
@@ -1601,7 +1656,8 @@ async function readConfig(dir, options) {
   });
   const userConfigModule = await import(builtConfigFileHref);
   const rawConfig = await normalizeConfig(
-    userConfigModule ? userConfigModule.config : { project: options?.projectRef }
+    userConfigModule?.config,
+    options?.projectRef ? { project: options?.projectRef } : void 0
   );
   const config = Config.parse(rawConfig);
   return {
@@ -1626,66 +1682,20 @@ async function resolveConfig(path6, config) {
   }
   return config;
 }
-async function normalizeConfig(config) {
+async function normalizeConfig(config, overrides) {
+  let normalized = config;
   if (typeof config === "function") {
-    config = config();
+    normalized = await config();
   }
-  return await config;
+  normalized = { ...normalized, ...overrides };
+  return normalized;
 }
 
 // src/utilities/initialBanner.ts
 import { spinner } from "@clack/prompts";
 import chalk3 from "chalk";
-import supportsColor from "supports-color";
 import checkForUpdate from "update-check";
 
-// src/utilities/cliOutput.ts
-import chalk2 from "chalk";
-var green = "#4FFF54";
-var purple = "#735BF3";
-function chalkPurple(text2) {
-  return chalk2.hex(purple)(text2);
-}
-function chalkGrey(text2) {
-  return chalk2.hex("#878C99")(text2);
-}
-function chalkError(text2) {
-  return chalk2.hex("#E11D48")(text2);
-}
-function chalkWarning(text2) {
-  return chalk2.yellow(text2);
-}
-function chalkSuccess(text2) {
-  return chalk2.hex("#28BF5C")(text2);
-}
-function chalkLink(text2) {
-  return chalk2.underline.hex("#D7D9DD")(text2);
-}
-function chalkWorker(text2) {
-  return chalk2.hex("#FFFF89")(text2);
-}
-function chalkTask(text2) {
-  return chalk2.hex("#60A5FA")(text2);
-}
-function chalkRun(text2) {
-  return chalk2.hex("#A78BFA")(text2);
-}
-function logo() {
-  return `${chalk2.hex(green).bold("Trigger")}${chalk2.hex(purple).bold(".dev")}`;
-}
-function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
-  let formattedDate = new Intl.DateTimeFormat("en-US", {
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false
-  }).format(date);
-  formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
-  return formattedDate;
-}
-
 // src/utilities/getVersion.ts
 import path3 from "path";
 function getVersion() {
@@ -1697,10 +1707,10 @@ function getVersion() {
 // src/utilities/initialBanner.ts
 async function printInitialBanner(performUpdateCheck = true) {
   const packageVersion = getVersion();
-  const text2 = `
+  const text3 = `
 ${logo()} ${chalkGrey(`(${packageVersion})`)}
 `;
-  logger.info(text2);
+  logger.info(text3);
   let maybeNewVersion;
   if (performUpdateCheck) {
     const loadingSpinner = spinner();
@@ -1724,19 +1734,19 @@ After installation, run Trigger.dev with \`npx trigger.dev\`.`
 }
 async function printStandloneInitialBanner(performUpdateCheck = true) {
   const packageVersion = getVersion();
-  let text2 = `
+  let text3 = `
 ${logo()} ${chalkGrey("(v3 Developer Preview)")}`;
   if (performUpdateCheck) {
     const maybeNewVersion = await updateCheck();
     if (maybeNewVersion !== void 0) {
-      text2 = `${text2} (update available ${chalk3.green(maybeNewVersion)})`;
+      text3 = `${text3} (update available ${chalk3.green(maybeNewVersion)})`;
     }
   }
-  logger.log(text2 + "\n" + (supportsColor.stdout ? chalkGrey("-".repeat(54)) : "-".repeat(54)));
+  logger.log(text3 + "\n" + chalkGrey("-".repeat(54)));
 }
 function printDevBanner() {
   logger.log(
-    `${chalkGrey("Key:")} ${chalkWorker("Worker")} ${chalkGrey("|")} ${chalkTask(
+    `${chalkGrey("Key:")} ${chalkWorker("Version")} ${chalkGrey("|")} ${chalkTask(
       "Task"
     )} ${chalkGrey("|")} ${chalkRun("Run")}`
   );
@@ -1764,20 +1774,14 @@ async function installPackages(packages, options) {
   const cwd = options?.cwd ?? process.cwd();
   logger.debug("Installing packages", { packages });
   await setPackageJsonDeps(join3(cwd, "package.json"), packages);
-  const childProcess2 = execa(
+  await execa(
     "npm",
     ["install", "--install-strategy", "nested", "--ignore-scripts", "--no-audit", "--no-fund"],
     {
       cwd,
-      stderr: "inherit"
+      stderr: "pipe"
     }
   );
-  await new Promise((res, rej) => {
-    childProcess2.on("error", (e) => rej(e));
-    childProcess2.on("close", () => res());
-  });
-  await childProcess2;
-  return;
 }
 function detectPackageNameFromImportPath(path6) {
   if (path6.startsWith("@")) {
@@ -2521,6 +2525,29 @@ async function login(options) {
       if (!opts.embedded) {
         intro2("Logging in to Trigger.dev");
       }
+      const accessTokenFromEnv = process.env.TRIGGER_ACCESS_TOKEN;
+      if (accessTokenFromEnv) {
+        const auth = {
+          accessToken: accessTokenFromEnv,
+          apiUrl: process.env.TRIGGER_API_URL ?? "https://api.trigger.dev"
+        };
+        const apiClient3 = new CliApiClient(auth.apiUrl, auth.accessToken);
+        const userData = await apiClient3.whoAmI();
+        if (!userData.success) {
+          throw new Error(userData.error);
+        }
+        return {
+          ok: true,
+          profile: options?.profile ?? "default",
+          userId: userData.data.userId,
+          email: userData.data.email,
+          dashboardUrl: userData.data.dashboardUrl,
+          auth: {
+            accessToken: auth.accessToken,
+            apiUrl: auth.apiUrl
+          }
+        };
+      }
       const authConfig = readAuthConfigProfile(options?.profile);
       if (authConfig && authConfig.accessToken) {
         const whoAmIResult = await whoAmI(
@@ -2721,10 +2748,45 @@ ${authorizationCodeResult.error}`
   });
 }
 
+// src/commands/deploy.ts
+import { Glob } from "glob";
+
 // src/utilities/build.ts
+import { readFileSync } from "node:fs";
 import { extname, isAbsolute } from "node:path";
 import tsConfigPaths from "tsconfig-paths";
-import { readFileSync } from "node:fs";
+function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
+  return {
+    name: "trigger-bundle-core",
+    setup(build3) {
+      build3.onResolve({ filter: /.*/ }, (args) => {
+        if (args.path !== "@trigger.dev/core/v3") {
+          return void 0;
+        }
+        const triggerSdkPath = __require.resolve("@trigger.dev/sdk/v3", { paths: [process.cwd()] });
+        logger.debug(`[${buildIdentifier}][trigger-bundle-core] Resolved @trigger.dev/sdk/v3`, {
+          ...args,
+          triggerSdkPath
+        });
+        const resolvedPath = __require.resolve("@trigger.dev/core/v3", {
+          paths: [triggerSdkPath]
+        });
+        logger.debug(
+          `[${buildIdentifier}][trigger-bundle-core] Externalizing @trigger.dev/core/v3`,
+          {
+            ...args,
+            triggerSdkPath,
+            resolvedPath
+          }
+        );
+        return {
+          path: resolvedPath,
+          external: false
+        };
+      });
+    }
+  };
+}
 function workerSetupImportConfigPlugin(configPath) {
   return {
     name: "trigger-worker-setup",
@@ -2751,8 +2813,8 @@ function workerSetupImportConfigPlugin(configPath) {
     }
   };
 }
-function bundleDependenciesPlugin(config) {
-  const matchPath = config.tsconfigPath ? createMatchPath(config.tsconfigPath) : void 0;
+function bundleDependenciesPlugin(buildIdentifier, dependenciesToBundle, tsconfigPath) {
+  const matchPath = tsconfigPath ? createMatchPath(tsconfigPath) : void 0;
   function resolvePath(id) {
     if (!matchPath) {
       return id;
@@ -2764,26 +2826,7 @@ function bundleDependenciesPlugin(config) {
     setup(build3) {
       build3.onResolve({ filter: /.*/ }, (args) => {
         const resolvedPath = resolvePath(args.path);
-        logger.ignore(`Checking if ${args.path} should be bundled or external`, {
-          ...args,
-          resolvedPath
-        });
         if (!isBareModuleId(resolvedPath)) {
-          logger.ignore(`Bundling ${args.path} because its not a bareModuleId`, {
-            ...args
-          });
-          return void 0;
-        }
-        if (args.path.startsWith("@trigger.dev/")) {
-          logger.ignore(`Bundling ${args.path} because its a trigger.dev package`, {
-            ...args
-          });
-          return void 0;
-        }
-        if (args.path === "superjson" || args.path === "copy-anything" || args.path === "is-what") {
-          logger.debug(`Bundling ${args.path} because its superjson/copy-anything/is-what`, {
-            ...args
-          });
           return void 0;
         }
         let loader;
@@ -2797,12 +2840,12 @@ function bundleDependenciesPlugin(config) {
         if (loader === "file") {
           return void 0;
         }
-        for (let pattern of config.dependenciesToBundle ?? []) {
+        for (let pattern of dependenciesToBundle ?? []) {
           if (typeof pattern === "string" ? args.path === pattern : pattern.test(args.path)) {
             return void 0;
           }
         }
-        logger.ignore(`Externalizing ${args.path}`, {
+        logger.ignore(`[${buildIdentifier}] Externalizing ${args.path}`, {
           ...args
         });
         return {
@@ -2890,8 +2933,347 @@ function getLoaderForFile(file) {
   throw new Error(`Cannot get loader for file ${file}`);
 }
 
+// src/utilities/deployErrors.ts
+import chalk4 from "chalk";
+import { relative as relative2 } from "node:path";
+import { groupTaskMetadataIssuesByTask } from "@trigger.dev/core/v3";
+function errorIsErrorLike(error) {
+  return error instanceof Error || typeof error === "object" && error !== null && "message" in error;
+}
+function parseBuildErrorStack(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (errorIsErrorLike(error)) {
+    if (typeof error.stack === "string") {
+      const isErrRequireEsm = error.stack.includes("ERR_REQUIRE_ESM");
+      let moduleName = null;
+      if (isErrRequireEsm) {
+        const moduleRegex = /node_modules\/(@[^\/]+\/[^\/]+|[^\/]+)\/[^\/]+\s/;
+        const match = moduleRegex.exec(error.stack);
+        if (match) {
+          moduleName = match[1];
+          return {
+            type: "esm-require-error",
+            moduleName
+          };
+        }
+      }
+    } else {
+      return error.message;
+    }
+  }
+}
+function logESMRequireError(parsedError, resolvedConfig) {
+  logger.log(
+    `
+${chalkError("X Error:")} The ${chalkPurple(
+      parsedError.moduleName
+    )} module is being required even though it's ESM only, and builds only support CommonJS. There are two ${chalk4.underline(
+      "possible"
+    )} ways to fix this:`
+  );
+  logger.log(
+    `
+${chalkGrey("\u25CB")} Dynamically import the module in your code: ${chalkGrey(
+      `const myModule = await import("${parsedError.moduleName}");`
+    )}`
+  );
+  if (resolvedConfig.status === "file") {
+    const relativePath = relative2(resolvedConfig.config.projectDir, resolvedConfig.path).replace(
+      /\\/g,
+      "/"
+    );
+    logger.log(
+      `${chalkGrey("\u25CB")} ${chalk4.underline("Or")} add ${chalkPurple(
+        parsedError.moduleName
+      )} to the ${chalkGreen("dependenciesToBundle")} array in your config file ${chalkGrey(
+        `(${relativePath})`
+      )}. This will bundle the module with your code.
+`
+    );
+  } else {
+    logger.log(
+      `${chalkGrey("\u25CB")} ${chalk4.underline("Or")} add ${chalkPurple(
+        parsedError.moduleName
+      )} to the ${chalkGreen("dependenciesToBundle")} array in your config file ${chalkGrey(
+        "(you'll need to create one)"
+      )}. This will bundle the module with your code.
+`
+    );
+  }
+}
+function parseNpmInstallError(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    if (typeof error.stack === "string") {
+      const isPackageNotFoundError = error.stack.includes("ERR! 404 Not Found") && error.stack.includes("is not in this registry");
+      let packageName = null;
+      if (isPackageNotFoundError) {
+        const packageNameRegex = /'([^']+)' is not in this registry/;
+        const match = packageNameRegex.exec(error.stack);
+        if (match) {
+          packageName = match[1];
+        }
+      }
+      if (packageName) {
+        return {
+          type: "package-not-found-error",
+          packageName
+        };
+      }
+      const noMatchingVersionRegex = /No matching version found for ([^\s]+)\s/;
+      const noMatchingVersionMatch = noMatchingVersionRegex.exec(error.stack);
+      if (noMatchingVersionMatch) {
+        return {
+          type: "no-matching-version-error",
+          packageName: noMatchingVersionMatch[1].replace(/.$/, "")
+        };
+      }
+      return error.message;
+    } else {
+      return error.message;
+    }
+  }
+  return "Unknown error";
+}
+function logTaskMetadataParseError(zodIssues, tasks) {
+  logger.log(
+    `
+${chalkError("X Error:")} Failed to start. The following ${zodIssues.length === 1 ? "task issue was" : "task issues were"} found:`
+  );
+  const groupedIssues = groupTaskMetadataIssuesByTask(tasks, zodIssues);
+  for (const key in groupedIssues) {
+    const taskWithIssues = groupedIssues[key];
+    if (!taskWithIssues) {
+      continue;
+    }
+    logger.log(
+      `
+  ${chalkWarning("\u276F")} ${taskWithIssues.exportName} ${chalkGrey("in")} ${taskWithIssues.filePath}`
+    );
+    for (const issue of taskWithIssues.issues) {
+      if (issue.path) {
+        logger.log(`    ${chalkError("x")} ${issue.path} ${chalkGrey(issue.message)}`);
+      } else {
+        logger.log(`    ${chalkError("x")} ${chalkGrey(issue.message)}`);
+      }
+    }
+  }
+}
+
+// src/utilities/safeJsonParse.ts
+function safeJsonParse(json) {
+  if (!json) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utilities/javascriptProject.ts
+import { $ } from "execa";
+import { join as join4 } from "node:path";
+
+// src/utilities/getUserPackageManager.ts
+import { findUp as findUp2 } from "find-up";
+async function getUserPackageManager(path6) {
+  try {
+    return await detectPackageManagerFromArtifacts(path6);
+  } catch (error) {
+    return detectPackageManagerFromCurrentCommand();
+  }
+}
+function detectPackageManagerFromCurrentCommand() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("yarn")) {
+      return "yarn";
+    } else if (userAgent.startsWith("pnpm")) {
+      return "pnpm";
+    } else {
+      return "npm";
+    }
+  } else {
+    return "npm";
+  }
+}
+async function detectPackageManagerFromArtifacts(path6) {
+  const packageFiles = [
+    { name: "yarn.lock", pm: "yarn" },
+    { name: "pnpm-lock.yaml", pm: "pnpm" },
+    { name: "package-lock.json", pm: "npm" },
+    { name: "npm-shrinkwrap.json", pm: "npm" }
+  ];
+  for (const { name, pm } of packageFiles) {
+    const foundPath = await findUp2(name, { cwd: path6 });
+    if (typeof foundPath === "string") {
+      return pm;
+    }
+  }
+  throw new Error("Could not detect package manager from artifacts");
+}
+
+// src/utilities/javascriptProject.ts
+var BuiltInModules = /* @__PURE__ */ new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib"
+]);
+var JavascriptProject = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  _packageJson;
+  _packageManager;
+  get packageJson() {
+    if (!this._packageJson) {
+      this._packageJson = readJSONFileSync(join4(this.projectPath, "package.json"));
+    }
+    return this._packageJson;
+  }
+  get scripts() {
+    return {
+      postinstall: this.packageJson.scripts?.postinstall
+    };
+  }
+  async 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") {
+      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();
+    try {
+      const version2 = await command.resolveDependencyVersion(packageName, {
+        cwd: this.projectPath
+      });
+      if (version2) {
+        return version2;
+      }
+    } catch (error) {
+      logger.debug(`Failed to resolve dependency version using ${command.name}`, {
+        packageName,
+        error
+      });
+    }
+  }
+};
+var PNPMCommands = class {
+  get name() {
+    return "pnpm";
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const cmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+    const { stdout } = await $({ cwd: options.cwd })`${cmd} list ${packageName} -r --json`;
+    const result = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageName} version using pnpm`, { result });
+    for (const dep of result) {
+      const dependency = dep.dependencies?.[packageName];
+      if (dependency) {
+        return dependency.version;
+      }
+    }
+  }
+};
+var NPMCommands = class {
+  get name() {
+    return "npm";
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const cmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    const { stdout } = await $({ cwd: options.cwd })`${cmd} list ${packageName} --json`;
+    const output = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageName} version using npm`, { output });
+    return this.#recursivelySearchDependencies(output.dependencies, packageName);
+  }
+  #recursivelySearchDependencies(dependencies2, packageName) {
+    for (const [name, dependency] of Object.entries(dependencies2)) {
+      if (name === packageName) {
+        return dependency.version;
+      }
+      if (dependency.dependencies) {
+        const result = this.#recursivelySearchDependencies(dependency.dependencies, packageName);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+};
+var YarnCommands = class {
+  get name() {
+    return "yarn";
+  }
+  async resolveDependencyVersion(packageName, options) {
+    const cmd = process.platform === "win32" ? "yarn.cmd" : "yarn";
+    const { stdout } = await $({ cwd: options.cwd })`${cmd} info ${packageName} --json`;
+    const lines = stdout.split("\n");
+    logger.debug(`Resolving ${packageName} version using yarn`, { lines });
+    for (const line of lines) {
+      const json = JSON.parse(line);
+      if (json.value === packageName) {
+        return json.children.Version;
+      }
+    }
+  }
+};
+
 // src/commands/deploy.ts
-import { Glob } from "glob";
 var DeployCommandOptions = CommonCommandOptions.extend({
   skipTypecheck: z4.boolean().default(false),
   skipDeploy: z4.boolean().default(false),
@@ -2918,7 +3300,7 @@ function configureDeployCommand(program2) {
       "Detected missing environment variables won't block deployment"
     ).option("-c, --config <config file>", "The name of the config file, found at [path]").option(
       "-p, --project-ref <project ref>",
-      "The project ref. Required if there is no config file."
+      "The project ref. Required if there is no config file. This will override the project specified in the config file."
     )
   ).addOption(
     new CommandOption(
@@ -3065,26 +3447,38 @@ async function _deployCommand(dir, options) {
         "Failed to initialize deployment. The deployment does not have any external build data. To deploy this project, you must use the --self-hosted flag to build and push the image yourself."
       );
     }
-    return buildAndPushImage({
-      registryHost,
-      auth: authorization.auth.accessToken,
-      imageTag: deploymentResponse.data.imageTag,
-      buildId: deploymentResponse.data.externalBuildData.buildId,
-      buildToken: deploymentResponse.data.externalBuildData.buildToken,
-      buildProjectId: deploymentResponse.data.externalBuildData.projectId,
-      cwd: compilation.path,
-      projectId: resolvedConfig.config.project,
-      deploymentId: deploymentResponse.data.id,
-      deploymentVersion: deploymentResponse.data.version,
-      contentHash: deploymentResponse.data.contentHash,
-      projectRef: resolvedConfig.config.project,
-      loadImage: options.loadImage,
-      buildPlatform: options.buildPlatform
-    });
+    return buildAndPushImage(
+      {
+        registryHost,
+        auth: authorization.auth.accessToken,
+        imageTag: deploymentResponse.data.imageTag,
+        buildId: deploymentResponse.data.externalBuildData.buildId,
+        buildToken: deploymentResponse.data.externalBuildData.buildToken,
+        buildProjectId: deploymentResponse.data.externalBuildData.projectId,
+        cwd: compilation.path,
+        projectId: resolvedConfig.config.project,
+        deploymentId: deploymentResponse.data.id,
+        deploymentVersion: deploymentResponse.data.version,
+        contentHash: deploymentResponse.data.contentHash,
+        projectRef: resolvedConfig.config.project,
+        loadImage: options.loadImage,
+        buildPlatform: options.buildPlatform
+      },
+      deploymentSpinner
+    );
   };
   const image = await buildImage();
   if (!image.ok) {
-    deploymentSpinner.stop(`Failed to build project image: ${image.error}`);
+    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}.`);
+    }
     throw new SkipLoggingError(`Failed to build project image: ${image.error}`);
   }
   const imageReference = options.selfHosted ? `${selfHostedRegistryHost ? `${selfHostedRegistryHost}/` : ""}${image.image}${image.digest ? `@${image.digest}` : ""}` : `${registryHost}/${image.image}${image.digest ? `@${image.digest}` : ""}`;
@@ -3144,10 +3538,27 @@ async function _deployCommand(dir, options) {
     }
     case "FAILED": {
       if (finishedDeployment.errorData) {
-        deploymentSpinner.stop(
-          `Deployment encountered an error: ${finishedDeployment.errorData.name}. ${deploymentLink}`
-        );
-        logger.error(finishedDeployment.errorData.stack);
+        if (finishedDeployment.errorData.name === "TaskMetadataParseError") {
+          const errorJson = safeJsonParse(finishedDeployment.errorData.stack);
+          if (errorJson) {
+            const parsedError2 = TaskMetadataFailedToParseData.safeParse(errorJson);
+            if (parsedError2.success) {
+              deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+              logTaskMetadataParseError(parsedError2.data.zodIssues, parsedError2.data.tasks);
+              throw new SkipLoggingError(
+                `Deployment encountered an error: ${finishedDeployment.errorData.name}`
+              );
+            }
+          }
+        }
+        const parsedError = finishedDeployment.errorData.stack ? parseBuildErrorStack(finishedDeployment.errorData) ?? finishedDeployment.errorData.message : finishedDeployment.errorData.message;
+        if (typeof parsedError === "string") {
+          deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+          logger.log(`${chalkError("X Error:")} ${parsedError}`);
+        } else {
+          deploymentSpinner.stop(`Deployment encountered an error. ${deploymentLink}`);
+          logESMRequireError(parsedError, resolvedConfig);
+        }
         throw new SkipLoggingError(
           `Deployment encountered an error: ${finishedDeployment.errorData.name}`
         );
@@ -3185,7 +3596,7 @@ async function checkEnvVars(envVars, config, options, environmentClient, apiUrl)
           environmentVariablesSpinner.stop(
             `Found missing env vars in ${options.env}: ${arrayToSentence(
               missingEnvironmentVariables
-            )}. ${options.ignoreEnvVarCheck ? "Continuing deployment because of --ignore-env-var-check. " : "Aborting deployment. "}${chalk4.bgBlueBright(
+            )}. ${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`
@@ -3246,7 +3657,7 @@ async function waitForDeploymentToFinish(deploymentId, client, timeoutInSeconds
     }
   });
 }
-async function buildAndPushImage(options) {
+async function buildAndPushImage(options, updater) {
   return tracer.startActiveSpan("buildAndPushImage", async (span) => {
     span.setAttributes({
       "options.registryHost": options.registryHost,
@@ -3302,15 +3713,24 @@ async function buildAndPushImage(options) {
     });
     const errors = [];
     try {
-      await new Promise((res, rej) => {
+      const processCode = await new Promise((res, rej) => {
         childProcess2.stderr?.on("data", (data) => {
-          const text2 = data.toString();
-          errors.push(text2);
-          logger.debug(text2);
+          const text3 = data.toString();
+          const lines = text3.split("\n").filter(Boolean);
+          errors.push(...lines);
+          logger.debug(text3);
         });
         childProcess2.on("error", (e) => rej(e));
-        childProcess2.on("close", () => res());
+        childProcess2.on("close", (code) => res(code));
       });
+      const logs = extractLogs(errors);
+      if (processCode !== 0) {
+        return {
+          ok: false,
+          error: `Error building image`,
+          logs
+        };
+      }
       const digest = extractImageDigest(errors);
       span.setAttributes({
         "image.digest": digest
@@ -3319,6 +3739,7 @@ async function buildAndPushImage(options) {
       return {
         ok: true,
         image: options.imageTag,
+        logs,
         digest
       };
     } catch (e) {
@@ -3326,7 +3747,8 @@ async function buildAndPushImage(options) {
       span.end();
       return {
         ok: false,
-        error: e instanceof Error ? e.message : JSON.stringify(e)
+        error: e instanceof Error ? e.message : JSON.stringify(e),
+        logs: extractLogs(errors)
       };
     }
   });
@@ -3372,15 +3794,22 @@ async function buildAndPushSelfHostedImage(options) {
     const errors = [];
     let digest;
     try {
-      await new Promise((res, rej) => {
+      const processCode = await new Promise((res, rej) => {
         buildProcess.stderr?.on("data", (data) => {
-          const text2 = data.toString();
-          errors.push(text2);
-          logger.debug(text2);
+          const text3 = data.toString();
+          errors.push(text3);
+          logger.debug(text3);
         });
         buildProcess.on("error", (e) => rej(e));
-        buildProcess.on("close", () => res());
+        buildProcess.on("close", (code) => res(code));
       });
+      if (processCode !== 0) {
+        return {
+          ok: false,
+          error: "Error building image",
+          logs: extractLogs(errors)
+        };
+      }
       digest = extractImageDigest(errors);
       span.setAttributes({
         "image.digest": digest
@@ -3390,7 +3819,8 @@ async function buildAndPushSelfHostedImage(options) {
       span.end();
       return {
         ok: false,
-        error: e instanceof Error ? e.message : JSON.stringify(e)
+        error: e instanceof Error ? e.message : JSON.stringify(e),
+        logs: extractLogs(errors)
       };
     }
     const pushArgs = ["push", imageRef].filter(Boolean);
@@ -3401,25 +3831,33 @@ async function buildAndPushSelfHostedImage(options) {
         cwd: options.cwd
       });
       try {
-        await new Promise((res, rej) => {
+        const processCode = await new Promise((res, rej) => {
           pushProcess.stdout?.on("data", (data) => {
-            const text2 = data.toString();
-            logger.debug(text2);
+            const text3 = data.toString();
+            logger.debug(text3);
           });
           pushProcess.stderr?.on("data", (data) => {
-            const text2 = data.toString();
-            logger.debug(text2);
+            const text3 = data.toString();
+            logger.debug(text3);
           });
           pushProcess.on("error", (e) => rej(e));
-          pushProcess.on("close", () => res());
+          pushProcess.on("close", (code) => res(code));
         });
+        if (processCode !== 0) {
+          return {
+            ok: false,
+            error: "Error pushing image",
+            logs: extractLogs(errors)
+          };
+        }
         span.end();
       } catch (e) {
         recordSpanException4(span, e);
         span.end();
         return {
           ok: false,
-          error: e instanceof Error ? e.message : JSON.stringify(e)
+          error: e instanceof Error ? e.message : JSON.stringify(e),
+          logs: extractLogs(errors)
         };
       }
     }
@@ -3427,21 +3865,25 @@ async function buildAndPushSelfHostedImage(options) {
     return {
       ok: true,
       image: options.imageTag,
-      digest
+      digest,
+      logs: extractLogs(errors)
     };
   });
 }
 function extractImageDigest(outputs) {
-  const imageDigestRegex = /sha256:[a-f0-9]{64}/;
+  const imageDigestRegex = /pushing manifest for .+(?<digest>sha256:[a-f0-9]{64})/;
   for (const line of outputs) {
-    if (line.includes("pushing manifest")) {
-      const imageDigestMatch = line.match(imageDigestRegex);
-      if (imageDigestMatch) {
-        return imageDigestMatch[0];
-      }
+    const imageDigestMatch = line.match(imageDigestRegex);
+    const digest = imageDigestMatch?.groups?.digest;
+    if (digest) {
+      return digest;
     }
   }
 }
+function extractLogs(outputs) {
+  const cleanedOutputs = outputs.map((line) => line.trim()).filter((line) => line !== "");
+  return cleanedOutputs.map((line) => line.trim()).join("\n");
+}
 async function compileProject(config, options, configPath) {
   return await tracer.startActiveSpan("compileProject", async (span) => {
     try {
@@ -3499,7 +3941,14 @@ async function compileProject(config, options, configPath) {
           TRIGGER_API_URL: `"${config.triggerUrl}"`,
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
-        plugins: [bundleDependenciesPlugin(config), workerSetupImportConfigPlugin(configPath)]
+        plugins: [
+          bundleDependenciesPlugin(
+            "workerFacade",
+            config.dependenciesToBundle,
+            config.tsconfigPath
+          ),
+          workerSetupImportConfigPlugin(configPath)
+        ]
       });
       if (result.errors.length > 0) {
         compileSpinner.stop("Build failed, aborting deployment");
@@ -3511,7 +3960,7 @@ async function compileProject(config, options, configPath) {
         throw new Error("Build failed, aborting deployment");
       }
       if (options.outputMetafile) {
-        await writeJSONFile(join4(options.outputMetafile, "worker.json"), result.metafile);
+        await writeJSONFile(join5(options.outputMetafile, "worker.json"), result.metafile);
       }
       const entryPointContents = readFileSync2(
         new URL(importResolve("./workers/prod/entry-point.js", import.meta.url)).href.replace(
@@ -3531,17 +3980,23 @@ async function compileProject(config, options, configPath) {
         write: false,
         minify: false,
         sourcemap: false,
-        packages: "external",
-        // https://esbuild.github.io/api/#packages
         logLevel: "error",
         platform: "node",
+        packages: "external",
         format: "cjs",
         // This is needed to support opentelemetry instrumentation that uses module patching
         target: ["node18", "es2020"],
         outdir: "out",
         define: {
           __PROJECT_CONFIG__: JSON.stringify(config)
-        }
+        },
+        plugins: [
+          bundleDependenciesPlugin(
+            "entryPoint.ts",
+            config.dependenciesToBundle,
+            config.tsconfigPath
+          )
+        ]
       });
       if (entryPointResult.errors.length > 0) {
         compileSpinner.stop("Build failed, aborting deployment");
@@ -3554,52 +4009,52 @@ async function compileProject(config, options, configPath) {
       }
       if (options.outputMetafile) {
         await writeJSONFile(
-          join4(options.outputMetafile, "entry-point.json"),
+          join5(options.outputMetafile, "entry-point.json"),
           entryPointResult.metafile
         );
       }
       const tempDir = await createTempDir();
       logger.debug(`Writing compiled files to ${tempDir}`);
-      const metaOutput = result.metafile.outputs[join4("out", "stdin.js")];
+      const metaOutput = result.metafile.outputs[join5("out", "stdin.js")];
       invariant(metaOutput, "Meta output for the result build is missing");
-      const entryPointMetaOutput = entryPointResult.metafile.outputs[join4("out", "stdin.js")];
+      const entryPointMetaOutput = entryPointResult.metafile.outputs[join5("out", "stdin.js")];
       invariant(entryPointMetaOutput, "Meta output for the entryPoint build is missing");
       const workerOutputFile = result.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js")
+        (file) => file.path === join5(config.projectDir, "out", "stdin.js")
       );
       invariant(workerOutputFile, "Output file for the result build is missing");
       const workerSourcemapFile = result.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js.map")
+        (file) => file.path === join5(config.projectDir, "out", "stdin.js.map")
       );
       invariant(workerSourcemapFile, "Sourcemap file for the result build is missing");
       const entryPointOutputFile = entryPointResult.outputFiles.find(
-        (file) => file.path === join4(config.projectDir, "out", "stdin.js")
+        (file) => file.path === join5(config.projectDir, "out", "stdin.js")
       );
       invariant(entryPointOutputFile, "Output file for the entryPoint build is missing");
       await writeFile2(
-        join4(tempDir, "worker.js"),
+        join5(tempDir, "worker.js"),
         `${workerOutputFile.text}
 //# sourceMappingURL=worker.js.map`
       );
-      await writeFile2(join4(tempDir, "worker.js.map"), workerSourcemapFile.text);
-      await writeFile2(join4(tempDir, "index.js"), entryPointOutputFile.text);
+      await writeFile2(join5(tempDir, "worker.js.map"), workerSourcemapFile.text);
+      await writeFile2(join5(tempDir, "index.js"), entryPointOutputFile.text);
+      logger.debug("Getting the imports for the worker and entryPoint builds", {
+        workerImports: metaOutput.imports,
+        entryPointImports: entryPointMetaOutput.imports
+      });
       const allImports = [...metaOutput.imports, ...entryPointMetaOutput.imports];
-      const externalPackageJson = await readJSONFile(join4(config.projectDir, "package.json"));
-      const dependencies2 = await gatherRequiredDependencies(
-        allImports,
-        config,
-        externalPackageJson
-      );
+      const javascriptProject = new JavascriptProject(config.projectDir);
+      const dependencies2 = await gatherRequiredDependencies(allImports, config, javascriptProject);
       const packageJsonContents = {
         name: "trigger-worker",
         version: "0.0.0",
         description: "",
         dependencies: dependencies2,
         scripts: {
-          postinstall: externalPackageJson?.scripts?.postinstall
+          ...javascriptProject.scripts
         }
       };
-      await writeJSONFile(join4(tempDir, "package.json"), packageJsonContents);
+      await writeJSONFile(join5(tempDir, "package.json"), packageJsonContents);
       await copyAdditionalFiles(config, tempDir);
       compileSpinner.stop("Project built successfully");
       const resolvingDependenciesResult = await resolveDependencies(
@@ -3609,12 +4064,12 @@ async function compileProject(config, options, configPath) {
         options
       );
       if (!resolvingDependenciesResult) {
-        throw new Error("Failed to resolve dependencies");
+        throw new SkipLoggingError("Failed to resolve dependencies");
       }
       const containerFilePath = new URL(
         importResolve("./Containerfile.prod", import.meta.url)
       ).href.replace("file://", "");
-      await copyFile(containerFilePath, join4(tempDir, "Containerfile"));
+      await copyFile(containerFilePath, join5(tempDir, "Containerfile"));
       const contentHasher = createHash("sha256");
       contentHasher.update(Buffer.from(entryPointOutputFile.text));
       contentHasher.update(Buffer.from(workerOutputFile.text));
@@ -3646,8 +4101,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 = join4(config.projectDir, ".trigger", "cache");
-    const cachePath = join4(cacheDir, `${digest}.json`);
+    const cacheDir = join5(config.projectDir, ".trigger", "cache");
+    const cachePath = join5(cacheDir, `${digest}.json`);
     span.setAttributes({
       "packageJson.digest": digest,
       "cache.path": cachePath,
@@ -3656,7 +4111,7 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
     try {
       const cachedPackageLock = await readFile2(cachePath, "utf-8");
       logger.debug(`Using cached package-lock.json for ${digest}`);
-      await writeFile2(join4(projectDir, "package-lock.json"), cachedPackageLock);
+      await writeFile2(join5(projectDir, "package-lock.json"), cachedPackageLock);
       span.setAttributes({
         "cache.hit": true
       });
@@ -3679,21 +4134,44 @@ async function resolveDependencies(projectDir, packageJsonContents, config, opti
           cwd: projectDir,
           stdio: logger.loggerLevel === "debug" ? "inherit" : "pipe"
         });
-        const packageLockContents = await readFile2(join4(projectDir, "package-lock.json"), "utf-8");
+        const packageLockContents = await readFile2(join5(projectDir, "package-lock.json"), "utf-8");
         logger.debug(`Writing package-lock.json to cache for ${digest}`);
         await mkdir(cacheDir, { recursive: true });
         await writeFile2(cachePath, packageLockContents);
-        await writeFile2(join4(projectDir, "package-lock.json"), packageLockContents);
+        await writeFile2(join5(projectDir, "package-lock.json"), packageLockContents);
         span.end();
         resolvingDepsSpinner.stop("Dependencies resolved");
         return true;
       } catch (installError) {
-        logger.debug(`Failed to resolve dependencies: ${JSON.stringify(installError)}`);
         recordSpanException4(span, installError);
         span.end();
-        resolvingDepsSpinner.stop(
-          "Failed to resolve dependencies. Rerun with --log-level=debug for more information"
-        );
+        const parsedError = parseNpmInstallError(installError);
+        if (typeof parsedError === "string") {
+          resolvingDepsSpinner.stop(`Failed to resolve dependencies: ${parsedError}`);
+        } else {
+          switch (parsedError.type) {
+            case "package-not-found-error": {
+              resolvingDepsSpinner.stop(`Failed to resolve dependencies`);
+              logger.log(
+                `
+${chalkError("X Error:")} The package ${chalkPurple(
+                  parsedError.packageName
+                )} could not be found in the npm registry.`
+              );
+              break;
+            }
+            case "no-matching-version-error": {
+              resolvingDepsSpinner.stop(`Failed to resolve dependencies`);
+              logger.log(
+                `
+${chalkError("X Error:")} The package ${chalkPurple(
+                  parsedError.packageName
+                )} could not resolve because the version doesn't exist`
+              );
+              break;
+            }
+          }
+        }
         return false;
       }
     }
@@ -3737,17 +4215,17 @@ async function typecheckProject(config, options) {
     }
   });
 }
-async function gatherRequiredDependencies(imports, config, projectPackageJson) {
+async function gatherRequiredDependencies(imports, config, project) {
   const dependencies2 = {};
   for (const file of imports) {
-    if (file.kind !== "require-call" || !file.external) {
+    if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
       continue;
     }
     const packageName = detectPackageNameFromImportPath(file.path);
     if (dependencies2[packageName]) {
       continue;
     }
-    const externalDependencyVersion = (projectPackageJson?.dependencies ?? {})[packageName];
+    const externalDependencyVersion = await project.resolve(packageName);
     if (externalDependencyVersion) {
       dependencies2[packageName] = stripWorkspaceFromVersion(externalDependencyVersion);
       continue;
@@ -3767,16 +4245,17 @@ async function gatherRequiredDependencies(imports, config, projectPackageJson) {
         dependencies2[packageParts.name] = packageParts.version;
         continue;
       } else {
-        const externalDependencyVersion = {
-          ...projectPackageJson?.devDependencies,
-          ...projectPackageJson?.dependencies
-        }[packageName];
+        const externalDependencyVersion = await project.resolve(packageParts.name, {
+          allowDev: true
+        });
         if (externalDependencyVersion) {
           dependencies2[packageParts.name] = externalDependencyVersion;
           continue;
         } else {
-          logger.warn(
-            `Could not find version for package ${packageName}, add a version specifier to the package name (e.g. ${packageParts.name}@latest) or add it to your project's package.json`
+          logger.log(
+            `${chalkWarning("X Warning:")} Could not find version for package ${chalkPurple(
+              packageName
+            )}, add a version specifier to the package name (e.g. ${packageParts.name}@latest) or add it to your project's package.json`
           );
         }
       }
@@ -3808,9 +4287,9 @@ async function copyAdditionalFiles(config, tempDir) {
           nodir: true
         });
         for await (const file of glob) {
-          const relativeDestinationPath = join4(
+          const relativeDestinationPath = join5(
             tempDir,
-            relative2(config.projectDir, file.fullpath())
+            relative3(config.projectDir, file.fullpath())
           );
           logger.debug(`Copying file ${file.fullpath()} to ${relativeDestinationPath}`);
           await mkdir(dirname(relativeDestinationPath), { recursive: true });
@@ -3827,7 +4306,7 @@ async function copyAdditionalFiles(config, tempDir) {
 }
 async function ensureLoggedIntoDockerRegistry(registryHost, auth) {
   const tmpDir = await createTempDir();
-  const dockerConfigPath = join4(tmpDir, "config.json");
+  const dockerConfigPath = join5(tmpDir, "config.json");
   await writeJSONFile(dockerConfigPath, {
     auths: {
       [registryHost]: {
@@ -3842,7 +4321,7 @@ 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"];
+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);
@@ -3874,7 +4353,7 @@ import { resolve as importResolve2 } from "import-meta-resolve";
 import { render, useInput } from "ink";
 import { createHash as createHash2 } from "node:crypto";
 import fs7, { readFileSync as readFileSync3 } from "node:fs";
-import { basename, dirname as dirname3, join as join5 } from "node:path";
+import { basename, dirname as dirname3, join as join6 } from "node:path";
 import pDebounce from "p-debounce";
 import { WebSocket } from "partysocket";
 import React, { Suspense, useEffect } from "react";
@@ -3890,6 +4369,14 @@ var UncaughtExceptionError = class extends Error {
     this.name = "UncaughtExceptionError";
   }
 };
+var TaskMetadataParseError = class extends Error {
+  constructor(zodIssues, tasks) {
+    super(`Failed to parse task metadata`);
+    this.zodIssues = zodIssues;
+    this.tasks = tasks;
+    this.name = "TaskMetadataParseError";
+  }
+};
 
 // src/workers/dev/backgroundWorker.ts
 import {
@@ -4099,6 +4586,12 @@ var BackgroundWorker = class {
       await installPackages(this.params.dependencies, { cwd: dirname2(this.path) });
     }
     let resolved = false;
+    const cwd = dirname2(this.path);
+    const fullEnv = {
+      ...this.params.env,
+      ...this.#readEnvVars()
+    };
+    logger.debug("Initializing worker", { path: this.path, cwd, fullEnv });
     this.tasks = await new Promise((resolve4, reject) => {
       const child = fork(this.path, {
         stdio: [
@@ -4110,10 +4603,8 @@ var BackgroundWorker = class {
           "pipe",
           "ipc"
         ],
-        env: {
-          ...this.params.env,
-          ...this.#readEnvVars()
-        }
+        cwd,
+        env: fullEnv
       });
       const timeout = setTimeout(() => {
         if (resolved) {
@@ -4135,6 +4626,11 @@ var BackgroundWorker = class {
           resolved = true;
           reject(new UncaughtExceptionError(message.payload.error, message.payload.origin));
           child.kill();
+        } else if (message.type === "TASKS_FAILED_TO_PARSE") {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(new TaskMetadataParseError(message.payload.zodIssues, message.payload.tasks));
+          child.kill();
         }
       });
       child.on("exit", (code) => {
@@ -4160,7 +4656,7 @@ var BackgroundWorker = class {
     }
     if (!this._taskRunProcesses.has(payload.execution.run.id)) {
       const taskRunProcess = new TaskRunProcess(
-        payload.execution.run.id,
+        payload.execution,
         this.path,
         {
           ...this.params.env,
@@ -4270,8 +4766,8 @@ var BackgroundWorker = class {
   }
 };
 var TaskRunProcess = class {
-  constructor(runId, path6, env, metadata, worker) {
-    this.runId = runId;
+  constructor(execution, path6, env, metadata, worker) {
+    this.execution = execution;
     this.path = path6;
     this.env = env;
     this.metadata = metadata;
@@ -4302,9 +4798,20 @@ var TaskRunProcess = class {
     await this.cleanup(true);
   }
   async initialize() {
-    logger.debug(`[${this.runId}] initializing task run process`, {
-      env: this.env,
-      path: this.path
+    const fullEnv = {
+      ...this.execution.run.isTest ? { TRIGGER_LOG_LEVEL: "debug" } : {},
+      ...this.env,
+      OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
+        [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
+      }),
+      OTEL_EXPORTER_OTLP_COMPRESSION: "none",
+      ...this.worker.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
+    };
+    const cwd = dirname2(this.path);
+    logger.debug(`[${this.execution.run.id}] initializing task run process`, {
+      env: fullEnv,
+      path: this.path,
+      cwd
     });
     this._child = fork(this.path, {
       stdio: [
@@ -4316,15 +4823,8 @@ var TaskRunProcess = class {
         "pipe",
         "ipc"
       ],
-      cwd: dirname2(this.path),
-      env: {
-        ...this.env,
-        OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
-          [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
-        }),
-        OTEL_EXPORTER_OTLP_COMPRESSION: "none",
-        ...this.worker.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
-      },
+      cwd,
+      env: fullEnv,
       execArgv: this.worker.debuggerOn ? ["--inspect-brk", "--trace-uncaught", "--no-warnings=ExperimentalWarning"] : ["--trace-uncaught", "--no-warnings=ExperimentalWarning"]
     });
     this._child.on("message", this.#handleMessage.bind(this));
@@ -4336,7 +4836,7 @@ var TaskRunProcess = class {
     if (kill && this._isBeingKilled) {
       return;
     }
-    logger.debug(`[${this.runId}] cleaning up task run process`, { kill });
+    logger.debug(`[${this.execution.run.id}] cleaning up task run process`, { kill });
     await this._sender.send("CLEANUP", {
       flush: true,
       kill
@@ -4367,10 +4867,13 @@ var TaskRunProcess = class {
     if (!completion.ok && typeof completion.retry !== "undefined") {
       return;
     }
-    if (execution.run.id === this.runId) {
+    if (execution.run.id === this.execution.run.id) {
       return;
     }
-    logger.debug(`[${this.runId}] task run completed notification`, { completion, execution });
+    logger.debug(`[${this.execution.run.id}] task run completed notification`, {
+      completion,
+      execution
+    });
     this._sender.send("TASK_RUN_COMPLETED_NOTIFICATION", {
       completion,
       execution
@@ -4408,7 +4911,7 @@ var TaskRunProcess = class {
     }
   }
   async #handleExit(code) {
-    logger.debug(`[${this.runId}] task run process exiting`, { code });
+    logger.debug(`[${this.execution.run.id}] task run process exiting`, { code });
     for (const [id, status] of this._attemptStatuses.entries()) {
       if (status === "PENDING") {
         this._attemptStatuses.set(id, "REJECTED");
@@ -4455,7 +4958,27 @@ var TaskRunProcess = class {
   }
 };
 
+// src/utilities/runtimeCheck.ts
+function runtimeCheck(minimumMajor, minimumMinor) {
+  if (typeof process === "undefined") {
+    throw "The dev CLI can only be run in a Node.js compatible environment";
+  }
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  const isBun = typeof process.versions.bun === "string";
+  if (major < minimumMajor || major === minimumMajor && minor < minimumMinor) {
+    if (isBun) {
+      throw `The dev CLI requires at least Node.js ${minimumMajor}.${minimumMinor}. You are running Bun ${process.versions.bun}, which is compatible with Node.js ${process.versions.node}`;
+    } else {
+      throw `The dev CLI requires at least Node.js ${minimumMajor}.${minimumMinor}. You are running Node.js ${process.versions.node}`;
+    }
+  }
+  logger.debug(
+    `Node.js version: ${process.versions.node}${isBun ? ` (Bun ${process.versions.bun})` : ""}`
+  );
+}
+
 // src/commands/dev.tsx
+import { findUp as findUp3, pathExists as pathExists2 } from "find-up";
 var apiClient;
 var DevCommandOptions = CommonCommandOptions.extend({
   debugger: z5.boolean().default(false),
@@ -4465,7 +4988,7 @@ var DevCommandOptions = CommonCommandOptions.extend({
 });
 function configureDevCommand(program2) {
   return commonOptions(
-    program2.command("dev").description("Run your Trigger.dev tasks locally").argument("[path]", "The path to the project", ".").option("-c, --config <config file>", "The name of the config file, found at [path]").option(
+    program2.command("dev").description("Run your Trigger.dev tasks locally").argument("[path]", "The path to the project", ".").option("-c, --config <config file>", "The name of the config file, found at [path].").option(
       "-p, --project-ref <project ref>",
       "The project ref. Required if there is no config file."
     ).option("--debugger", "Enable the debugger").option("--debug-otel", "Enable OpenTelemetry debugging")
@@ -4475,22 +4998,35 @@ function configureDevCommand(program2) {
     });
   });
 }
+var MINIMUM_NODE_MAJOR = 18;
+var MINIMUM_NODE_MINOR = 16;
 async function devCommand(dir, options) {
+  try {
+    runtimeCheck(MINIMUM_NODE_MAJOR, MINIMUM_NODE_MINOR);
+  } catch (e) {
+    logger.log(`${chalkError("X Error:")} ${e}`);
+    process.exitCode = 1;
+    return;
+  }
   const authorization = await isLoggedIn(options.profile);
   if (!authorization.ok) {
     if (authorization.error === "fetch failed") {
-      logger.error("Fetch failed. Platform down?");
+      logger.log(
+        `${chalkError(
+          "X Error:"
+        )} Connecting to the server failed. Please check your internet connection or contact eric@trigger.dev for help.`
+      );
     } else {
-      logger.error("You must login first. Use `trigger.dev login` to login.");
+      logger.log(`${chalkError("X Error:")} You must login first. Use the \`login\` CLI command.`);
     }
     process.exitCode = 1;
     return;
   }
-  const devInstance = await startDev(dir, options, authorization.auth);
+  const devInstance = await startDev(dir, options, authorization.auth, authorization.dashboardUrl);
   const { waitUntilExit } = devInstance.devReactElement;
   await waitUntilExit();
 }
-async function startDev(dir, options, authorization) {
+async function startDev(dir, options, authorization, dashboardUrl) {
   let rerender;
   try {
     if (options.logLevel) {
@@ -4528,6 +5064,7 @@ async function startDev(dir, options, authorization) {
       return /* @__PURE__ */ React.createElement(
         DevUI,
         {
+          dashboardUrl,
           config: configParam,
           apiUrl,
           apiKey: devEnv.data.apiKey,
@@ -4559,6 +5096,7 @@ async function startDev(dir, options, authorization) {
 }
 function useDev({
   config,
+  dashboardUrl,
   apiUrl,
   apiKey,
   environmentClient,
@@ -4588,7 +5126,7 @@ function useDev({
       }
     });
     const backgroundWorkerCoordinator = new BackgroundWorkerCoordinator(
-      `${apiUrl}/projects/v3/${config.project}`
+      `${dashboardUrl}/projects/v3/${config.project}`
     );
     websocket.addEventListener("open", async (event) => {
     });
@@ -4708,7 +5246,12 @@ function useDev({
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
-          bundleDependenciesPlugin(config),
+          bundleTriggerDevCore("workerFacade", config.tsconfigPath),
+          bundleDependenciesPlugin(
+            "workerFacade",
+            (config.dependenciesToBundle ?? []).concat([/^@trigger.dev/]),
+            config.tsconfigPath
+          ),
           workerSetupImportConfigPlugin(configPath),
           {
             name: "trigger.dev v3",
@@ -4723,19 +5266,19 @@ function useDev({
                 if (!firstBuild) {
                   logger.log(chalkGrey("\u25CB Building background worker\u2026"));
                 }
-                const metaOutputKey = join5("out", `stdin.js`);
+                const metaOutputKey = join6("out", `stdin.js`);
                 const metaOutput = result.metafile.outputs[metaOutputKey];
                 if (!metaOutput) {
                   throw new Error(`Could not find metafile`);
                 }
-                const outputFileKey = join5(config.projectDir, metaOutputKey);
+                const outputFileKey = join6(config.projectDir, metaOutputKey);
                 const outputFile = result.outputFiles.find((file) => file.path === outputFileKey);
                 if (!outputFile) {
                   throw new Error(
                     `Could not find output file for entry point ${metaOutput.entryPoint}`
                   );
                 }
-                const sourceMapFileKey = join5(config.projectDir, `${metaOutputKey}.map`);
+                const sourceMapFileKey = join6(config.projectDir, `${metaOutputKey}.map`);
                 const sourceMapFile = result.outputFiles.find(
                   (file) => file.path === sourceMapFileKey
                 );
@@ -4746,7 +5289,7 @@ function useDev({
                   logger.log(chalkGrey("\u25CB No changes detected, skipping build\u2026"));
                   return;
                 }
-                const fullPath = join5(config.projectDir, ".trigger", `${contentHash}.js`);
+                const fullPath = join6(config.projectDir, ".trigger", `${contentHash}.js`);
                 const sourceMapPath = `${fullPath}.map`;
                 const outputFileWithSourceMap = `${outputFile.text}
 //# sourceMappingURL=${basename(sourceMapPath)}`;
@@ -4759,7 +5302,7 @@ function useDev({
                   await fs7.promises.writeFile(sourceMapPath2, sourceMapFile.text);
                 }
                 const environmentVariablesResponse = await environmentClient.getEnvironmentVariables(config.project);
-                const processEnv = gatherProcessEnv();
+                const processEnv = await gatherProcessEnv();
                 const backgroundWorker = new BackgroundWorker(fullPath, {
                   projectConfig: config,
                   dependencies: dependencies2,
@@ -4827,17 +5370,52 @@ function useDev({
                     backgroundWorker
                   );
                 } catch (e) {
-                  if (e instanceof UncaughtExceptionError) {
+                  if (e instanceof TaskMetadataParseError) {
+                    logTaskMetadataParseError(e.zodIssues, e.tasks);
+                    return;
+                  } else if (e instanceof UncaughtExceptionError) {
+                    const parsedBuildError = parseBuildErrorStack(e.originalError);
+                    if (parsedBuildError && typeof parsedBuildError !== "string") {
+                      logESMRequireError(
+                        parsedBuildError,
+                        configPath ? { status: "file", path: configPath, config } : { status: "in-memory", config }
+                      );
+                      return;
+                    } else {
+                    }
                     if (e.originalError.stack) {
-                      logger.error("Background worker failed to start", e.originalError.stack);
+                      logger.log(
+                        `${chalkError("X Error:")} Worker failed to start`,
+                        e.originalError.stack
+                      );
                     }
                     return;
                   }
-                  if (e instanceof Error) {
-                    logger.error(`Background worker failed to start`, e.stack);
-                    return;
+                  const parsedError = parseNpmInstallError(e);
+                  if (typeof parsedError === "string") {
+                    logger.log(`${chalkError("X Error:")} ${parsedError}`);
+                  } else {
+                    switch (parsedError.type) {
+                      case "package-not-found-error": {
+                        logger.log(
+                          `
+${chalkError("X Error:")} The package ${chalkPurple(
+                            parsedError.packageName
+                          )} could not be found in the npm registry.`
+                        );
+                        break;
+                      }
+                      case "no-matching-version-error": {
+                        logger.log(
+                          `
+${chalkError("X Error:")} The package ${chalkPurple(
+                            parsedError.packageName
+                          )} could not resolve because the version doesn't exist`
+                        );
+                        break;
+                      }
+                    }
                   }
-                  logger.error(`Background worker failed to start: ${e}`);
                 }
               });
             }
@@ -4901,8 +5479,11 @@ function WebsocketFactory(apiKey) {
 }
 async function gatherRequiredDependencies2(outputMeta, config) {
   const dependencies2 = {};
+  logger.debug("Gathering required dependencies from imports", {
+    imports: outputMeta.imports
+  });
   for (const file of outputMeta.imports) {
-    if (file.kind !== "require-call" || !file.external) {
+    if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
       continue;
     }
     const packageName = detectPackageNameFromImportPath(file.path);
@@ -4915,7 +5496,7 @@ async function gatherRequiredDependencies2(outputMeta, config) {
     }
   }
   if (config.additionalPackages) {
-    const projectPackageJson = await readJSONFile(join5(config.projectDir, "package.json"));
+    const projectPackageJson = await readJSONFile(join6(config.projectDir, "package.json"));
     for (const packageName of config.additionalPackages) {
       if (dependencies2[packageName]) {
         continue;
@@ -4945,16 +5526,14 @@ async function gatherRequiredDependencies2(outputMeta, config) {
 function createDuplicateTaskIdOutputErrorMessage(duplicateTaskIds, taskResources) {
   const duplicateTable = duplicateTaskIds.map((id) => {
     const tasks = taskResources.filter((task) => task.id === id);
-    return `id "${chalkPurple(id)}" was found in:
-${tasks.map((task) => `${task.filePath} -> ${task.exportName}`).join("\n")}`;
-  }).join("\n\n");
-  return `Duplicate task ids detected:
+    return `
 
-${duplicateTable}
-
-`;
+${chalkTask(id)} was found in:${tasks.map((task) => `
+${task.filePath} -> ${task.exportName}`).join("")}`;
+  }).join("");
+  return `Duplicate ${chalkTask("task id")} detected:${duplicateTable}`;
 }
-function gatherProcessEnv() {
+async function gatherProcessEnv() {
   const env = {
     NODE_ENV: process.env.NODE_ENV ?? "development",
     PATH: process.env.PATH,
@@ -4965,12 +5544,37 @@ function gatherProcessEnv() {
     NVM_BIN: process.env.NVM_BIN,
     LANG: process.env.LANG,
     TERM: process.env.TERM,
-    NODE_PATH: process.env.NODE_PATH,
+    NODE_PATH: await amendNodePathWithPnpmNodeModules(process.env.NODE_PATH),
     HOME: process.env.HOME,
     BUN_INSTALL: process.env.BUN_INSTALL
   };
   return Object.fromEntries(Object.entries(env).filter(([key, value]) => value !== void 0));
 }
+async function amendNodePathWithPnpmNodeModules(nodePath) {
+  const pnpmModulesPath = await findPnpmNodeModulesPath();
+  if (!pnpmModulesPath) {
+    return nodePath;
+  }
+  if (nodePath) {
+    if (nodePath.includes(pnpmModulesPath)) {
+      return nodePath;
+    }
+    return `${nodePath}:${pnpmModulesPath}`;
+  }
+  return pnpmModulesPath;
+}
+async function findPnpmNodeModulesPath() {
+  return await findUp3(
+    async (directory) => {
+      const pnpmModules = join6(directory, "node_modules", ".pnpm", "node_modules");
+      const hasPnpmNodeModules = await pathExists2(pnpmModules);
+      if (hasPnpmNodeModules) {
+        return pnpmModules;
+      }
+    },
+    { type: "directory" }
+  );
+}
 
 // src/commands/init.ts
 import { intro as intro4, isCancel, log as log3, outro as outro4, select as select2, spinner as spinner5, text } from "@clack/prompts";
@@ -4979,11 +5583,11 @@ import {
   flattenAttributes as flattenAttributes3,
   recordSpanException as recordSpanException5
 } from "@trigger.dev/core/v3";
-import chalk5 from "chalk";
+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 join6, relative as relative3, resolve as resolve3 } from "node:path";
+import { join as join7, relative as relative4, resolve as resolve3 } from "node:path";
 import terminalLink3 from "terminal-link";
 import { z as z6 } from "zod";
 
@@ -5028,45 +5632,6 @@ function replaceAll(input, replacements) {
   return output;
 }
 
-// src/utilities/getUserPackageManager.ts
-import pathModule2 from "path";
-async function getUserPackageManager(path6) {
-  try {
-    return await detectPackageManagerFromArtifacts(path6);
-  } catch (error) {
-    return detectPackageManagerFromCurrentCommand();
-  }
-}
-function detectPackageManagerFromCurrentCommand() {
-  const userAgent = process.env.npm_config_user_agent;
-  if (userAgent) {
-    if (userAgent.startsWith("yarn")) {
-      return "yarn";
-    } else if (userAgent.startsWith("pnpm")) {
-      return "pnpm";
-    } else {
-      return "npm";
-    }
-  } else {
-    return "npm";
-  }
-}
-async function detectPackageManagerFromArtifacts(path6) {
-  const packageFiles = [
-    { name: "yarn.lock", pm: "yarn" },
-    { name: "pnpm-lock.yaml", pm: "pnpm" },
-    { name: "package-lock.json", pm: "npm" },
-    { name: "npm-shrinkwrap.json", pm: "npm" }
-  ];
-  for (const { name, pm } of packageFiles) {
-    const exists = await pathExists(pathModule2.join(path6, name));
-    if (exists) {
-      return pm;
-    }
-  }
-  throw new Error("Could not detect package manager from artifacts");
-}
-
 // src/utilities/resolveInternalFilePath.ts
 import { resolve as importResolve3 } from "import-meta-resolve";
 function resolveInternalFilePath(filePath) {
@@ -5162,7 +5727,7 @@ async function _initCommand(dir, options) {
   log3.success("Successfully initialized project for Trigger.dev v3 \u{1FAE1}");
   log3.info("Next steps:");
   log3.info(
-    `   1. To start developing, run ${chalk5.green(
+    `   1. To start developing, run ${chalk6.green(
       `npx trigger.dev@${options.tag} dev`
     )} in your project directory`
   );
@@ -5177,7 +5742,7 @@ async function _initCommand(dir, options) {
     `   4. Need help? Join our ${terminalLink3(
       "Discord community",
       "https://trigger.dev/discord"
-    )} or email us at ${chalk5.cyan("help@trigger.dev")}`
+    )} or email us at ${chalk6.cyan("help@trigger.dev")}`
   );
   outro4(`Project initialized successfully. Happy coding!`);
 }
@@ -5219,19 +5784,19 @@ async function createTriggerDir(dir, options) {
         "cli.example": example
       });
       if (example === "none") {
-        await createFile(join6(triggerDir, ".gitkeep"), "");
+        await createFile(join7(triggerDir, ".gitkeep"), "");
         log3.step(`Created directory at ${location}`);
         span.end();
         return { location, isCustomValue: location !== defaultValue };
       }
       const exampleFile = resolveInternalFilePath(`./templates/examples/${example}.ts.template`);
-      const outputPath = join6(triggerDir, "example.ts");
+      const outputPath = join7(triggerDir, "example.ts");
       await createFileFromTemplate({
         templatePath: exampleFile,
         outputPath,
         replacements: {}
       });
-      const relativeOutputPath = relative3(process.cwd(), outputPath);
+      const relativeOutputPath = relative4(process.cwd(), outputPath);
       log3.step(`Created example file at ${relativeOutputPath}`);
       span.end();
       return { location, isCustomValue: location !== defaultValue };
@@ -5248,7 +5813,7 @@ async function gitIgnoreDotTriggerDir(dir, options) {
   return await tracer.startActiveSpan("gitIgnoreDotTriggerDir", async (span) => {
     try {
       const projectDir = resolve3(process.cwd(), dir);
-      const gitIgnorePath = join6(projectDir, ".gitignore");
+      const gitIgnorePath = join7(projectDir, ".gitignore");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.gitIgnorePath": gitIgnorePath
@@ -5282,7 +5847,7 @@ async function addConfigFileToTsConfig(dir, options) {
   return await tracer.startActiveSpan("createTriggerDir", async (span) => {
     try {
       const projectDir = resolve3(process.cwd(), dir);
-      const tsconfigPath = join6(projectDir, "tsconfig.json");
+      const tsconfigPath = join7(projectDir, "tsconfig.json");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.tsconfigPath": tsconfigPath
@@ -5369,7 +5934,7 @@ async function writeConfigFile(dir, project, options, triggerDir) {
       spnnr.start("Creating config file");
       const projectDir = resolve3(process.cwd(), dir);
       const templatePath = resolveInternalFilePath("./templates/trigger.config.ts.template");
-      const outputPath = join6(projectDir, "trigger.config.ts");
+      const outputPath = join7(projectDir, "trigger.config.ts");
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.templatePath": templatePath,
@@ -5385,7 +5950,7 @@ async function writeConfigFile(dir, project, options, triggerDir) {
         outputPath,
         override: options.overrideConfig
       });
-      const relativePathToOutput = relative3(process.cwd(), outputPath);
+      const relativePathToOutput = relative4(process.cwd(), outputPath);
       spnnr.stop(
         result.success ? `Config file created at ${relativePathToOutput}` : `Failed to create config file: ${result.error}`
       );
@@ -5467,12 +6032,14 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
 // src/commands/logout.ts
 var LogoutCommandOptions = CommonCommandOptions;
 function configureLogoutCommand(program2) {
-  return commonOptions(program2.command("logout").description("Logout of Trigger.dev")).action(async (options) => {
-    await handleTelemetry(async () => {
-      await printInitialBanner(false);
-      await logoutCommand(options);
-    });
-  });
+  return commonOptions(program2.command("logout").description("Logout of Trigger.dev")).action(
+    async (options) => {
+      await handleTelemetry(async () => {
+        await printInitialBanner(false);
+        await logoutCommand(options);
+      });
+    }
+  );
 }
 async function logoutCommand(options) {
   return await wrapCommandAction("logoutCommand", LogoutCommandOptions, options, async (opts) => {
@@ -5482,11 +6049,46 @@ async function logoutCommand(options) {
 async function logout(options) {
   const config = readAuthConfigProfile(options.profile);
   if (!config?.accessToken) {
-    logger.info(`You are already logged out [${options.profile ?? "default"}]`);
+    logger.info(`You are already logged out [${options.profile}]`);
+    return;
+  }
+  deleteAuthConfigProfile(options.profile);
+  logger.info(`Logged out of Trigger.dev [${options.profile}]`);
+}
+
+// src/commands/list-profiles.ts
+import { log as log4, outro as outro5 } from "@clack/prompts";
+var ListProfilesOptions = CommonCommandOptions;
+function configureListProfilesCommand(program2) {
+  return program2.command("list-profiles").description("List all of your CLI profiles").option(
+    "-l, --log-level <level>",
+    "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
+    "log"
+  ).option("--skip-telemetry", "Opt-out of sending telemetry").action(async (options) => {
+    await handleTelemetry(async () => {
+      await printInitialBanner(true);
+      await listProfilesCommand(options);
+    });
+  });
+}
+async function listProfilesCommand(options) {
+  return await wrapCommandAction("listProfiles", ListProfilesOptions, options, async (opts) => {
+    return await listProfiles(opts);
+  });
+}
+async function listProfiles(options) {
+  const authConfig = readAuthConfigFile();
+  if (!authConfig) {
+    logger.info("No profiles found");
     return;
   }
-  writeAuthConfigProfile({ ...config, accessToken: void 0, apiUrl: void 0 }, options.profile);
-  logger.info(`Logged out of Trigger.dev [${options.profile ?? "default"}]`);
+  const profiles = Object.keys(authConfig);
+  log4.message("Profiles:");
+  for (const profile of profiles) {
+    const profileConfig = authConfig[profile];
+    log4.info(`${profile}${profileConfig?.apiUrl ? ` - ${chalkGrey(profileConfig.apiUrl)}` : ""}`);
+  }
+  outro5("Retrieve account info by running whoami --profile <profile>");
 }
 
 // src/cli/index.ts
@@ -5498,6 +6100,7 @@ configureDevCommand(program);
 configureDeployCommand(program);
 configureWhoamiCommand(program);
 configureLogoutCommand(program);
+configureListProfilesCommand(program);
 
 // src/index.ts
 var main = async () => {