trigger.dev 3.0.0-beta.8 → 3.0.0-beta.9

package/dist/index.js

@@ -794,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 relative3 } 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.8";
+var version = "3.0.0-beta.9";
 var dependencies = {
   "@clack/prompts": "^0.7.0",
   "@depot/cli": "0.0.1-cli.2.55.0",
@@ -834,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",
@@ -900,7 +899,6 @@ var package_default = {
     "@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",
@@ -2962,7 +2960,6 @@ function parseBuildErrorStack(error) {
       return error.message;
     }
   }
-  return "Unknown error";
 }
 function logESMRequireError(parsedError, resolvedConfig) {
   logger.log(
@@ -3076,6 +3073,203 @@ function safeJsonParse(json) {
   }
 }
 
+// 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
 var DeployCommandOptions = CommonCommandOptions.extend({
   skipTypecheck: z4.boolean().default(false),
@@ -3274,7 +3468,7 @@ async function _deployCommand(dir, options) {
   if (!image.ok) {
     deploymentSpinner.stop(`Failed to build project.`);
     if (image.logs.trim() !== "") {
-      const logPath = join4(await createTempDir(), `build-${deploymentResponse.data.shortCode}.log`);
+      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})`
@@ -3354,7 +3548,7 @@ async function _deployCommand(dir, options) {
             }
           }
         }
-        const parsedError = finishedDeployment.errorData.stack ? parseBuildErrorStack(finishedDeployment.errorData) : finishedDeployment.errorData.message;
+        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}`);
@@ -3763,7 +3957,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(
@@ -3812,56 +4006,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(
@@ -3876,7 +4066,7 @@ async function compileProject(config, options, configPath) {
       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));
@@ -3908,8 +4098,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,
@@ -3918,7 +4108,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
       });
@@ -3941,11 +4131,11 @@ 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;
@@ -4022,7 +4212,7 @@ async function typecheckProject(config, options) {
     }
   });
 }
-async function gatherRequiredDependencies(imports, config, projectPackageJson) {
+async function gatherRequiredDependencies(imports, config, project) {
   const dependencies2 = {};
   for (const file of imports) {
     if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
@@ -4032,7 +4222,7 @@ async function gatherRequiredDependencies(imports, config, projectPackageJson) {
     if (dependencies2[packageName]) {
       continue;
     }
-    const externalDependencyVersion = (projectPackageJson?.dependencies ?? {})[packageName];
+    const externalDependencyVersion = await project.resolve(packageName);
     if (externalDependencyVersion) {
       dependencies2[packageName] = stripWorkspaceFromVersion(externalDependencyVersion);
       continue;
@@ -4052,10 +4242,9 @@ 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;
@@ -4095,7 +4284,7 @@ async function copyAdditionalFiles(config, tempDir) {
           nodir: true
         });
         for await (const file of glob) {
-          const relativeDestinationPath = join4(
+          const relativeDestinationPath = join5(
             tempDir,
             relative3(config.projectDir, file.fullpath())
           );
@@ -4114,7 +4303,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]: {
@@ -4161,7 +4350,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";
@@ -4786,7 +4975,7 @@ function runtimeCheck(minimumMajor, minimumMinor) {
 }
 
 // src/commands/dev.tsx
-import { findUp as findUp2, pathExists as pathExists2 } from "find-up";
+import { findUp as findUp3, pathExists as pathExists2 } from "find-up";
 var apiClient;
 var DevCommandOptions = CommonCommandOptions.extend({
   debugger: z5.boolean().default(false),
@@ -4830,11 +5019,11 @@ async function devCommand(dir, options) {
     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) {
@@ -4872,6 +5061,7 @@ async function startDev(dir, options, authorization) {
       return /* @__PURE__ */ React.createElement(
         DevUI,
         {
+          dashboardUrl,
           config: configParam,
           apiUrl,
           apiKey: devEnv.data.apiKey,
@@ -4903,6 +5093,7 @@ async function startDev(dir, options, authorization) {
 }
 function useDev({
   config,
+  dashboardUrl,
   apiUrl,
   apiKey,
   environmentClient,
@@ -4932,7 +5123,7 @@ function useDev({
       }
     });
     const backgroundWorkerCoordinator = new BackgroundWorkerCoordinator(
-      `${apiUrl}/projects/v3/${config.project}`
+      `${dashboardUrl}/projects/v3/${config.project}`
     );
     websocket.addEventListener("open", async (event) => {
     });
@@ -5072,19 +5263,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
                 );
@@ -5095,7 +5286,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)}`;
@@ -5181,7 +5372,7 @@ function useDev({
                     return;
                   } else if (e instanceof UncaughtExceptionError) {
                     const parsedBuildError = parseBuildErrorStack(e.originalError);
-                    if (typeof parsedBuildError !== "string") {
+                    if (parsedBuildError && typeof parsedBuildError !== "string") {
                       logESMRequireError(
                         parsedBuildError,
                         configPath ? { status: "file", path: configPath, config } : { status: "in-memory", config }
@@ -5302,7 +5493,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;
@@ -5370,9 +5561,9 @@ async function amendNodePathWithPnpmNodeModules(nodePath) {
   return pnpmModulesPath;
 }
 async function findPnpmNodeModulesPath() {
-  return await findUp2(
+  return await findUp3(
     async (directory) => {
-      const pnpmModules = join5(directory, "node_modules", ".pnpm", "node_modules");
+      const pnpmModules = join6(directory, "node_modules", ".pnpm", "node_modules");
       const hasPnpmNodeModules = await pathExists2(pnpmModules);
       if (hasPnpmNodeModules) {
         return pnpmModules;
@@ -5393,7 +5584,7 @@ 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 relative4, 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";
 
@@ -5438,45 +5629,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) {
@@ -5629,13 +5781,13 @@ 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,
@@ -5658,7 +5810,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
@@ -5692,7 +5844,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
@@ -5779,7 +5931,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,