trigger.dev 0.0.0-v3-prerelease-20240624162135 → 0.0.0-v3-prerelease-20240628191401

package/dist/index.js

@@ -794,12 +794,11 @@ import { readFileSync as readFileSync2 } from "node:fs";
 import { copyFile, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, join as join6, posix, relative as relative3 } 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-prerelease-20240624162135";
+var version = "0.0.0-v3-prerelease-20240628191401";
 var dependencies = {
   "@anatine/esbuild-decorators": "^0.2.19",
   "@clack/prompts": "^0.7.0",
@@ -816,7 +815,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-base": "^1.22.0",
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
-  "@trigger.dev/core": "workspace:0.0.0-v3-prerelease-20240624162135",
+  "@trigger.dev/core": "workspace:0.0.0-v3-prerelease-20240628191401",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -851,12 +850,12 @@ var dependencies = {
   "terminal-link": "^3.0.0",
   "tiny-invariant": "^1.2.0",
   "tsconfig-paths": "^4.2.0",
+  typescript: "^5.4.0",
   "update-check": "^1.5.4",
   url: "^0.11.1",
   ws: "^8.12.0",
   zod: "3.22.3",
-  "zod-validation-error": "^1.5.0",
-  typescript: "^5.4.0"
+  "zod-validation-error": "^1.5.0"
 };
 var package_default = {
   name: "trigger.dev",
@@ -909,7 +908,7 @@ var package_default = {
     "npm-run-all": "^4.1.5",
     open: "^10.0.3",
     "p-retry": "^6.1.0",
-    rimraf: "^3.0.2",
+    rimraf: "^5.0.7",
     tsup: "^8.0.1",
     "type-fest": "^3.6.0",
     typescript: "^5.3.3",
@@ -1357,6 +1356,7 @@ import { outro } from "@clack/prompts";
 // src/utilities/cliOutput.ts
 import { log } from "@clack/prompts";
 import chalk2 from "chalk";
+import terminalLink from "terminal-link";
 var green = "#4FFF54";
 var purple = "#735BF3";
 function chalkGreen(text3) {
@@ -1428,6 +1428,12 @@ function prettyWarning(header, body, footer) {
     `${prettyPrefix}${header}${prettyBody ? `${spacing}${prettyBody}` : ""}${prettyFooter ? `${spacing}${prettyFooter}` : ""}`
   );
 }
+function cliLink(text3, url, options) {
+  return terminalLink(text3, url, {
+    fallback: (text4, url2) => `${text4} ${url2}`,
+    ...options
+  });
+}
 
 // src/cli/common.ts
 var CommonCommandOptions = z.object({
@@ -3125,7 +3131,6 @@ function getLoaderForFile(file) {
 import chalk4 from "chalk";
 import { relative as relative2 } from "node:path";
 import { groupTaskMetadataIssuesByTask } from "@trigger.dev/core/v3";
-import terminalLink from "terminal-link";
 
 // src/utilities/links.ts
 var docs = {
@@ -3148,13 +3153,9 @@ function parseBuildErrorStack(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];
+      if (error.stack.includes("ERR_REQUIRE_ESM")) {
+        const moduleName = getPackageNameFromEsmRequireError(error.stack);
+        if (moduleName) {
           return {
             type: "esm-require-error",
             moduleName
@@ -3166,6 +3167,27 @@ function parseBuildErrorStack(error) {
     }
   }
 }
+function getPackageNameFromEsmRequireError(stack) {
+  const pathRegex = /require\(\) of ES Module (.*) from/;
+  const pathMatch = pathRegex.exec(stack);
+  if (!pathMatch) {
+    return;
+  }
+  const filePath = pathMatch[1];
+  if (!filePath) {
+    return;
+  }
+  const lastPart = filePath.split("node_modules/").pop();
+  if (!lastPart) {
+    return;
+  }
+  const moduleRegex = /(@[^\/]+\/[^\/]+|[^\/]+)/;
+  const match = moduleRegex.exec(lastPart);
+  if (!match) {
+    return;
+  }
+  return match[1];
+}
 function logESMRequireError(parsedError, resolvedConfig) {
   logger.log(
     `
@@ -3205,7 +3227,7 @@ ${chalkGrey("\u25CB")} Dynamically import the module in your code: ${chalkGrey(
     );
   }
   logger.log(
-    `${chalkGrey("\u25CB")} For more info see the ${terminalLink("relevant docs", docs.config.esm)}.
+    `${chalkGrey("\u25CB")} For more info see the ${cliLink("relevant docs", docs.config.esm)}.
 `
   );
 }
@@ -3277,6 +3299,13 @@ import { join as join4 } from "node:path";
 // src/utilities/getUserPackageManager.ts
 import { findUp as findUp2 } from "find-up";
 import { basename } from "path";
+var LOCKFILES = {
+  npm: "package-lock.json",
+  npmShrinkwrap: "npm-shrinkwrap.json",
+  pnpm: "pnpm-lock.yaml",
+  yarn: "yarn.lock",
+  bun: "bun.lockb"
+};
 async function getUserPackageManager(path7) {
   const packageManager = await detectPackageManager(path7);
   logger.debug("Detected package manager", { packageManager });
@@ -3304,24 +3333,23 @@ function detectPackageManagerFromCurrentCommand() {
   }
 }
 async function detectPackageManagerFromArtifacts(path7) {
-  const artifacts = {
-    yarn: "yarn.lock",
-    pnpm: "pnpm-lock.yaml",
-    npm: "package-lock.json",
-    npmShrinkwrap: "npm-shrinkwrap.json"
-  };
-  const foundPath = await findUp2(Object.values(artifacts), { cwd: path7 });
+  const foundPath = await findUp2(Object.values(LOCKFILES), { 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:
+    case LOCKFILES.yarn:
+      logger.debug("Found yarn artifact", { foundPath });
       return "yarn";
-    case artifacts.pnpm:
+    case LOCKFILES.pnpm:
+      logger.debug("Found pnpm artifact", { foundPath });
       return "pnpm";
-    case artifacts.npm:
-    case artifacts.npmShrinkwrap:
+    case LOCKFILES.npm:
+    case LOCKFILES.npmShrinkwrap:
+      logger.debug("Found npm artifact", { foundPath });
+    case LOCKFILES.bun:
+      logger.debug("Found bun artifact", { foundPath });
       return "npm";
     default:
       throw new Error(`Unhandled package manager detection path: ${foundPath}`);
@@ -3349,10 +3377,53 @@ var JavascriptProject = class {
     }
     return this._packageJson;
   }
+  get allowedPackageJson() {
+    const disallowedKeys = [
+      "scripts",
+      "devDependencies",
+      "dependencies",
+      "peerDependencies",
+      "author",
+      "contributors",
+      "funding",
+      "bugs",
+      "files",
+      "keywords",
+      "main",
+      "module",
+      "type",
+      "bin",
+      "browser",
+      "man",
+      "directories",
+      "repository",
+      "peerDependenciesMeta",
+      "optionalDependencies",
+      "engines",
+      "os",
+      "cpu",
+      "private",
+      "publishConfig",
+      "workspaces"
+    ];
+    return Object.keys(this.packageJson).reduce(
+      (acc, key) => {
+        if (!disallowedKeys.includes(key)) {
+          acc[key] = this.packageJson[key];
+        }
+        return acc;
+      },
+      {}
+    );
+  }
   get scripts() {
-    return {
-      postinstall: this.packageJson.scripts?.postinstall ?? ""
-    };
+    return this.#filterScripts();
+  }
+  #filterScripts() {
+    if (!this.packageJson.scripts || typeof this.packageJson.scripts !== "object") {
+      return {};
+    }
+    return this.packageJson.scripts;
   }
   async install() {
     const command = await this.#getCommand();
@@ -3718,27 +3789,49 @@ Latest:      ${newCliVersion}`,
   }
   const triggerDependencies = getTriggerDependencies(packageJson);
   function getVersionMismatches(deps, targetVersion) {
-    const mismatches = [];
+    const mismatches2 = [];
     for (const dep of deps) {
       if (dep.version === targetVersion) {
         continue;
       }
-      mismatches.push(dep);
+      mismatches2.push(dep);
+    }
+    const extractRelease = (version2) => {
+      const release = Number(version2.split("3.0.0-beta.")[1]);
+      return release || void 0;
+    };
+    let isDowngrade2 = false;
+    const targetRelease = extractRelease(targetVersion);
+    if (targetRelease) {
+      isDowngrade2 = mismatches2.some((dep) => {
+        const depRelease = extractRelease(dep.version);
+        if (!depRelease) {
+          return false;
+        }
+        return depRelease > targetRelease;
+      });
     }
-    return mismatches;
+    return {
+      mismatches: mismatches2,
+      isDowngrade: isDowngrade2
+    };
   }
-  const versionMismatches = getVersionMismatches(triggerDependencies, cliVersion);
-  if (versionMismatches.length === 0) {
+  const { mismatches, isDowngrade } = getVersionMismatches(triggerDependencies, cliVersion);
+  if (mismatches.length === 0) {
     if (!embedded) {
       outro4(`Nothing to do${newCliVersion ? " ..but you should really update your CLI!" : ""}`);
       return hasOutput;
     }
     return hasOutput;
   }
-  prettyWarning(
-    "Mismatch between your CLI version and installed packages",
-    "We recommend pinned versions for guaranteed compatibility"
-  );
+  if (isDowngrade) {
+    prettyError("Some of the installed @trigger.dev packages are newer than your CLI version");
+  } else {
+    prettyWarning(
+      "Mismatch between your CLI version and installed packages",
+      "We recommend pinned versions for guaranteed compatibility"
+    );
+  }
   if (!process.stdout.isTTY) {
     outro4("Deploy failed");
     console.log(
@@ -3751,13 +3844,24 @@ Latest:      ${newCliVersion}`,
   CLI version: ${cliVersion}
   
   Current package versions that don't match the CLI:
-  ${versionMismatches.map((dep) => `- ${dep.name}@${dep.version}`).join("\n")}
+  ${mismatches.map((dep) => `- ${dep.name}@${dep.version}`).join("\n")}
+`
+    );
+    process.exit(1);
+  }
+  if (isDowngrade) {
+    printUpdateTable("Versions", mismatches, cliVersion, "installed", "CLI");
+    outro4("CLI update required!");
+    logger.log(
+      `${chalkError(
+        "X Error:"
+      )} Please update your CLI. Alternatively, use \`--skip-update-check\` at your own risk.
 `
     );
     process.exit(1);
   }
   log4.message("");
-  const userWantsToUpdate = await updateConfirmation(versionMismatches, cliVersion);
+  const userWantsToUpdate = await updateConfirmation(mismatches, cliVersion);
   if (isCancel(userWantsToUpdate)) {
     throw new OutroCommandError();
   }
@@ -3787,7 +3891,7 @@ Latest:      ${newCliVersion}`,
     );
   };
   process.prependOnceListener("exit", exitHandler);
-  mutatePackageJsonWithUpdatedPackages(packageJson, versionMismatches, cliVersion);
+  mutatePackageJsonWithUpdatedPackages(packageJson, mismatches, cliVersion);
   await writeJSONFile(packageJsonPath, packageJson, true);
   async function revertPackageJsonChanges() {
     await writeJSONFile(packageJsonPath, readonlyPackageJson, true);
@@ -3850,17 +3954,17 @@ function mutatePackageJsonWithUpdatedPackages(packageJson, depsToUpdate, targetV
     packageJson[type][name] = targetVersion;
   }
 }
-function printUpdateTable(depsToUpdate, targetVersion) {
-  log4.message("Suggested updates");
+function printUpdateTable(heading, depsToUpdate, targetVersion, oldColumn = "old", newColumn = "new") {
+  log4.message(heading);
   const tableData = depsToUpdate.map((dep) => ({
     package: dep.name,
-    old: dep.version,
-    new: targetVersion
+    [oldColumn]: dep.version,
+    [newColumn]: targetVersion
   }));
   logger.table(tableData);
 }
 async function updateConfirmation(depsToUpdate, targetVersion) {
-  printUpdateTable(depsToUpdate, targetVersion);
+  printUpdateTable("Suggested updates", depsToUpdate, targetVersion);
   let confirmMessage = "Would you like to apply those updates?";
   return await confirm({
     message: confirmMessage
@@ -4198,7 +4302,7 @@ ${authorization.error}`
     await preExitTasks();
     throw new SkipLoggingError(`Deployment failed to complete: ${finishedDeployment}`);
   }
-  const deploymentLink = terminalLink2(
+  const deploymentLink = cliLink(
     "View deployment",
     `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.config.project}/deployments/${finishedDeployment.shortCode}`
   );
@@ -4288,7 +4392,7 @@ function checkLogsForWarnings(logs) {
   const warnings = [
     {
       regex: /prisma:warn We could not find your Prisma schema/,
-      message: `Prisma generate failed to find the default schema. Did you include it in config.additionalFiles? ${terminalLink2(
+      message: `Prisma generate failed to find the default schema. Did you include it in config.additionalFiles? ${cliLink(
         "Config docs",
         docs.config.prisma
       )}
@@ -4330,7 +4434,7 @@ function checkLogsForErrors(logs) {
     {
       regex: /Error: Provided --schema at (?<schema>.*) doesn't exist/,
       message: `Prisma generate failed to find the specified schema at "$schema".
-Did you include it in config.additionalFiles? ${terminalLink2(
+Did you include it in config.additionalFiles? ${cliLink(
         "Config docs",
         docs.config.prisma
       )}`
@@ -4339,11 +4443,11 @@ Did you include it in config.additionalFiles? ${terminalLink2(
       regex: /sh: 1: (?<packageOrBinary>.*): not found/,
       message: `$packageOrBinary not found
 
-If it's a package: Include it in ${terminalLink2(
+If it's a package: Include it in ${cliLink(
         "config.additionalPackages",
         docs.config.prisma
       )}
-If it's a binary:  Please ${terminalLink2(
+If it's a binary:  Please ${cliLink(
         "get in touch",
         getInTouch
       )} and we'll see what we can do!`
@@ -4821,12 +4925,11 @@ async function compileProject(config, options, configPath) {
       const dependencies2 = await resolveRequiredDependencies(allImports, config, javascriptProject);
       logger.debug("gatherRequiredDependencies()", { dependencies: dependencies2 });
       const packageJsonContents = {
-        name: "trigger-worker",
-        version: "0.0.0",
-        description: "",
+        ...javascriptProject.allowedPackageJson,
         dependencies: dependencies2,
         scripts: {
-          ...javascriptProject.scripts
+          ...javascriptProject.scripts,
+          ...typeof config.postInstall === "string" ? { postinstall: config.postInstall } : {}
         }
       };
       span.setAttributes({
@@ -4841,7 +4944,7 @@ async function compileProject(config, options, configPath) {
 
 ${copyResult.noMatches.map((glob) => `- "${glob}"`).join("\n")}
 
-If this is unexpected you should check your ${terminalLink2(
+If this is unexpected you should check your ${cliLink(
             "glob patterns",
             "https://github.com/isaacs/node-glob?tab=readme-ov-file#glob-primer"
           )} are valid.`
@@ -4859,14 +4962,6 @@ If this is unexpected you should check your ${terminalLink2(
       }
       const containerFilePath = join6(cliRootPath(), "Containerfile.prod");
       let containerFileContents = readFileSync2(containerFilePath, "utf-8");
-      if (config.postInstall) {
-        containerFileContents = containerFileContents.replace(
-          "__POST_INSTALL__",
-          `RUN ${config.postInstall}`
-        );
-      } else {
-        containerFileContents = containerFileContents.replace("__POST_INSTALL__", "");
-      }
       await writeFile2(join6(tempDir, "Containerfile"), containerFileContents);
       const contentHasher = createHash("sha256");
       contentHasher.update(Buffer.from(entryPointOutputFile.text));
@@ -5299,9 +5394,11 @@ var TaskMetadataParseError = class extends Error {
   }
 };
 var UnexpectedExitError = class extends Error {
-  constructor(code) {
+  constructor(code, signal, stderr) {
     super(`Unexpected exit with code ${code}`);
     this.code = code;
+    this.signal = signal;
+    this.stderr = stderr;
     this.name = "UnexpectedExitError";
   }
 };
@@ -5323,6 +5420,21 @@ var SigKillTimeoutProcessError = class extends Error {
     this.name = "SigKillTimeoutProcessError";
   }
 };
+function getFriendlyErrorMessage(code, signal, stderr) {
+  const message = (text3) => {
+    if (signal) {
+      return `[${signal}] ${text3}`;
+    } else {
+      return text3;
+    }
+  };
+  if (code === 137 || stderr?.includes("OOMErrorHandler")) {
+    return message(
+      "Process ran out of memory! Try choosing a machine preset with more memory for this task."
+    );
+  }
+  return message(`Process exited with code ${code}.`);
+}
 
 // src/workers/dev/backgroundWorker.ts
 import {
@@ -5338,7 +5450,6 @@ import dotenv from "dotenv";
 import { Evt } from "evt";
 import { fork } from "node:child_process";
 import { dirname as dirname2, resolve as resolve4 } from "node:path";
-import terminalLink3 from "terminal-link";
 var BackgroundWorkerCoordinator = class {
   constructor(baseURL) {
     this.baseURL = baseURL;
@@ -5575,7 +5686,7 @@ var BackgroundWorker = class {
         resolved = true;
         child.kill();
         reject(new Error("Worker timed out"));
-      }, 5e3);
+      }, 2e4);
       child.on("message", async (msg) => {
         const message = this._handler.parseMessage(msg);
         if (message.type === "TASKS_READY" && !resolved) {
@@ -5745,7 +5856,7 @@ var BackgroundWorker = class {
     const logsUrl = `${baseURL}/runs/${execution.run.id}`;
     const pipe = chalkGrey("|");
     const bullet = chalkGrey("\u25CB");
-    const link = chalkLink(terminalLink3("View logs", logsUrl));
+    const link = chalkLink(cliLink("View logs", logsUrl));
     let timestampPrefix = chalkGrey(prettyPrintDate(payload.execution.attempt.startedAt));
     const workerPrefix = chalkWorker(this.metadata.version);
     const taskPrefix = chalkTask(execution.task.id);
@@ -5822,7 +5933,9 @@ var BackgroundWorker = class {
           retry: void 0,
           error: {
             type: "INTERNAL_ERROR",
-            code: TaskRunErrorCodes.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE
+            code: TaskRunErrorCodes.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE,
+            message: getFriendlyErrorMessage(e.code, e.signal, e.stderr),
+            stackTrace: e.stderr
           }
         };
       }
@@ -5884,6 +5997,7 @@ var TaskRunProcess = class {
   _currentExecution;
   _isBeingKilled = false;
   _isBeingCancelled = false;
+  _stderr = [];
   /**
    * @deprecated use onTaskRunHeartbeat instead
    */
@@ -6043,7 +6157,13 @@ var TaskRunProcess = class {
         } else if (this._isBeingKilled) {
           rejecter(new CleanupProcessError());
         } else {
-          rejecter(new UnexpectedExitError(code ?? -1));
+          rejecter(
+            new UnexpectedExitError(
+              code ?? -1,
+              signal,
+              this._stderr.length ? this._stderr.join("\n") : void 0
+            )
+          );
         }
       }
     }
@@ -6072,9 +6192,14 @@ var TaskRunProcess = class {
     const runId = chalkRun(
       `${this._currentExecution.run.id}.${this._currentExecution.attempt.number}`
     );
+    const errorLine = data.toString();
     logger.log(
-      `${chalkError("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${runId} ${data.toString()}`
+      `${chalkError("\u25CB")} ${chalkGrey(prettyPrintDate(/* @__PURE__ */ new Date()))} ${runId} ${errorLine}`
     );
+    if (this._stderr.length > 100) {
+      this._stderr.shift();
+    }
+    this._stderr.push(errorLine);
   }
   #kill() {
     logger.debug(`[${this.runId}] #kill()`, { pid: this.pid });
@@ -6594,12 +6719,18 @@ function useDev({
                     throw new Error(backgroundWorkerRecord.error);
                   }
                   backgroundWorker.metadata = backgroundWorkerRecord.data;
+                  backgroundWorker;
+                  const testUrl = `${dashboardUrl}/projects/v3/${config.project}/test?environment=dev`;
+                  const runsUrl = `${dashboardUrl}/projects/v3/${config.project}/runs?envSlug=dev`;
+                  const pipe = chalkGrey("|");
+                  const bullet = chalkGrey("\u25CB");
+                  const arrow = chalkGrey("->");
+                  const testLink = chalkLink(cliLink("Test tasks", testUrl));
+                  const runsLink = chalkLink(cliLink("View runs", runsUrl));
+                  const workerStarted = chalkGrey("Background worker started");
+                  const workerVersion = chalkWorker(backgroundWorkerRecord.data.version);
                   logger.log(
-                    `${chalkGrey(
-                      `\u25CB Background worker started -> ${chalkWorker(
-                        backgroundWorkerRecord.data.version
-                      )}`
-                    )}`
+                    `${bullet} ${workerStarted} ${arrow} ${workerVersion} ${pipe} ${testLink} ${pipe} ${runsLink}`
                   );
                   firstBuild = false;
                   await backgroundWorkerCoordinator.registerWorker(
@@ -6607,6 +6738,9 @@ function useDev({
                     backgroundWorker
                   );
                 } catch (e) {
+                  logger.debug("Error starting background worker", {
+                    error: e
+                  });
                   if (e instanceof TaskMetadataParseError) {
                     logTaskMetadataParseError(e.zodIssues, e.tasks);
                     return;
@@ -6837,11 +6971,10 @@ import { context as context3, trace as trace3 } from "@opentelemetry/api";
 import { flattenAttributes as flattenAttributes4 } from "@trigger.dev/core/v3";
 import { recordSpanException as recordSpanException6 } from "@trigger.dev/core/v3/workers";
 import chalk5 from "chalk";
-import { execa as execa3 } from "execa";
-import jsoncParser from "jsonc-parser";
+import { ExecaError as ExecaError2, execa as execa3 } from "execa";
+import { applyEdits, modify, findNodeAtLocation, parseTree, getNodeValue } from "jsonc-parser";
 import { writeFile as writeFile3 } from "node:fs/promises";
 import { join as join8, relative as relative4, resolve as resolve5 } from "node:path";
-import terminalLink4 from "terminal-link";
 import { z as z6 } from "zod";
 
 // src/utilities/createFileFromTemplate.ts
@@ -6886,12 +7019,12 @@ function replaceAll(input, replacements) {
 }
 
 // src/commands/init.ts
-var { applyEdits, modify, findNodeAtLocation, parseTree, getNodeValue } = jsoncParser;
 var InitCommandOptions = CommonCommandOptions.extend({
   projectRef: z6.string().optional(),
   overrideConfig: z6.boolean().default(false),
   tag: z6.string().default("beta"),
-  skipPackageInstall: z6.boolean().default(false)
+  skipPackageInstall: z6.boolean().default(false),
+  pkgArgs: z6.string().optional()
 });
 function configureInitCommand(program2) {
   return commonOptions(
@@ -6902,7 +7035,10 @@ function configureInitCommand(program2) {
       "-t, --tag <package tag>",
       "The version of the @trigger.dev/sdk package to install",
       version
-    ).option("--skip-package-install", "Skip installing the @trigger.dev/sdk package").option("--override-config", "Override the existing config file if it exists")
+    ).option("--skip-package-install", "Skip installing the @trigger.dev/sdk package").option("--override-config", "Override the existing config file if it exists").option(
+      "--pkg-args <args>",
+      "Additional arguments to pass to the package manager, accepts CSV for multiple args"
+    )
   ).action(async (path7, options) => {
     await handleTelemetry(async () => {
       await printStandloneInitialBanner(true);
@@ -6918,6 +7054,7 @@ async function initCommand(dir, options) {
 async function _initCommand(dir, options) {
   const span = trace3.getSpan(context3.active());
   intro5("Initializing project");
+  await detectTsConfig(dir, options);
   const authorization = await login({
     embedded: true,
     defaultApiUrl: options.apiUrl,
@@ -6968,7 +7105,7 @@ async function _initCommand(dir, options) {
   await writeConfigFile(dir, selectedProject, options, triggerDir);
   await addConfigFileToTsConfig(dir, options);
   await gitIgnoreDotTriggerDir(dir, options);
-  const projectDashboard = terminalLink4(
+  const projectDashboard = cliLink(
     "project dashboard",
     `${authorization.dashboardUrl}/projects/v3/${selectedProject.externalRef}`
   );
@@ -6981,13 +7118,10 @@ async function _initCommand(dir, options) {
   );
   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.`
+    `   3. Head over to our ${cliLink("v3 docs", "https://trigger.dev/docs/v3")} to learn more.`
   );
   log6.info(
-    `   4. Need help? Join our ${terminalLink4(
+    `   4. Need help? Join our ${cliLink(
       "Discord community",
       "https://trigger.dev/discord"
     )} or email us at ${chalk5.cyan("help@trigger.dev")}`
@@ -7092,8 +7226,39 @@ async function gitIgnoreDotTriggerDir(dir, options) {
     }
   });
 }
+async function detectTsConfig(dir, options) {
+  return await tracer.startActiveSpan("detectTsConfig", async (span) => {
+    try {
+      const projectDir = resolve5(process.cwd(), dir);
+      const tsconfigPath = join8(projectDir, "tsconfig.json");
+      span.setAttributes({
+        "cli.projectDir": projectDir,
+        "cli.tsconfigPath": tsconfigPath
+      });
+      const tsconfigExists = await pathExists(tsconfigPath);
+      if (!tsconfigExists) {
+        prettyError(
+          "No tsconfig.json found",
+          `The init command needs to be run in a TypeScript project. You can create one like this:`,
+          `npm install typescript --save-dev
+npx tsc --init
+`
+        );
+        throw new Error("TypeScript required");
+      }
+      logger.debug("tsconfig.json exists", { tsconfigPath });
+      span.end();
+    } catch (e) {
+      if (!(e instanceof SkipCommandError)) {
+        recordSpanException6(span, e);
+      }
+      span.end();
+      throw e;
+    }
+  });
+}
 async function addConfigFileToTsConfig(dir, options) {
-  return await tracer.startActiveSpan("createTriggerDir", async (span) => {
+  return await tracer.startActiveSpan("addConfigFileToTsConfig", async (span) => {
     try {
       const projectDir = resolve5(process.cwd(), dir);
       const tsconfigPath = join8(projectDir, "tsconfig.json");
@@ -7144,49 +7309,58 @@ async function addConfigFileToTsConfig(dir, options) {
 async function installPackages2(dir, options) {
   return await tracer.startActiveSpan("installPackages", async (span) => {
     const installSpinner = spinner();
+    let pkgManager;
     try {
       const projectDir = resolve5(process.cwd(), dir);
-      const pkgManager = await getUserPackageManager(projectDir);
+      pkgManager = await getUserPackageManager(projectDir);
       span.setAttributes({
         "cli.projectDir": projectDir,
         "cli.packageManager": pkgManager,
         "cli.tag": options.tag
       });
+      const userArgs = options.pkgArgs?.split(",") ?? [];
+      const execaOptions = { cwd: projectDir };
+      let installProcess;
+      let args;
       switch (pkgManager) {
         case "npm": {
-          installSpinner.start(`Running npm install @trigger.dev/sdk@${options.tag}`);
-          await execa3("npm", ["install", "--save-exact", `@trigger.dev/sdk@${options.tag}`], {
-            cwd: projectDir,
-            stdio: options.logLevel === "debug" ? "inherit" : "ignore"
-          });
-          break;
-        }
-        case "pnpm": {
-          installSpinner.start(`Running pnpm add @trigger.dev/sdk@${options.tag}`);
-          await execa3("pnpm", ["add", `@trigger.dev/sdk@${options.tag}`], {
-            cwd: projectDir,
-            stdio: options.logLevel === "debug" ? "inherit" : "ignore"
-          });
+          args = ["install", "--save-exact", ...userArgs, `@trigger.dev/sdk@${options.tag}`];
           break;
         }
+        case "pnpm":
         case "yarn": {
-          installSpinner.start(`Running yarn add @trigger.dev/sdk@${options.tag}`);
-          await execa3("yarn", ["add", `@trigger.dev/sdk@${options.tag}`], {
-            cwd: projectDir,
-            stdio: options.logLevel === "debug" ? "inherit" : "ignore"
-          });
+          args = ["add", ...userArgs, `@trigger.dev/sdk@${options.tag}`];
           break;
         }
       }
+      installSpinner.start(`Running ${pkgManager} ${args.join(" ")}`);
+      installProcess = execa3(pkgManager, args, execaOptions);
+      const handleProcessOutput = (data) => {
+        logger.debug(data.toString());
+      };
+      installProcess.stderr?.on("data", handleProcessOutput);
+      installProcess.stdout?.on("data", handleProcessOutput);
+      await installProcess;
       installSpinner.stop(`@trigger.dev/sdk@${options.tag} installed`);
       span.end();
     } catch (e) {
-      installSpinner.stop(
-        `Failed to install @trigger.dev/sdk@${options.tag}. Rerun command with --log-level debug for more details.`
-      );
+      if (options.logLevel === "debug") {
+        installSpinner.stop(`Failed to install @trigger.dev/sdk@${options.tag}.`);
+      } else {
+        installSpinner.stop(
+          `Failed to install @trigger.dev/sdk@${options.tag}. Rerun command with --log-level debug for more details.`
+        );
+      }
       if (!(e instanceof SkipCommandError)) {
         recordSpanException6(span, e);
       }
+      if (e instanceof ExecaError2) {
+        if (pkgManager) {
+          e.message += ` 
+
+Note: You can pass additional args to ${pkgManager} by using --pkg-args. For example: trigger.dev init --pkg-args="--workspace-root"`;
+        }
+      }
       span.end();
       throw e;
     }
@@ -7255,7 +7429,7 @@ async function selectProject(apiClient2, dashboardUrl, projectRef) {
         throw new Error(`Failed to get projects: ${projectsResponse.error}`);
       }
       if (projectsResponse.data.length === 0) {
-        const newProjectLink = terminalLink4(
+        const newProjectLink = cliLink(
           "Create new project",
           `${dashboardUrl}/projects/new?version=v3`
         );